diff --git a/pandas/tests/indexes/datetimes/test_arithmetic.py b/pandas/tests/indexes/datetimes/test_arithmetic.py
index f6f8eccf4e30c..92790c690840b 100644
--- a/pandas/tests/indexes/datetimes/test_arithmetic.py
+++ b/pandas/tests/indexes/datetimes/test_arithmetic.py
@@ -2,6 +2,7 @@
 import warnings
 from datetime import datetime, timedelta
 import operator
+from itertools import product
 
 import pytest
 
@@ -15,6 +16,7 @@
                     DatetimeIndex, TimedeltaIndex,
                     date_range)
 from pandas._libs import tslib
+from pandas._libs.tslibs.offsets import shift_months
 
 
 @pytest.fixture(params=[None, 'UTC', 'Asia/Tokyo',
@@ -933,3 +935,16 @@ def test_datetime64_with_DateOffset(klass, assert_func):
                  Timestamp('2000-02-29', tz='US/Central')], name='a')
     assert_func(result, exp)
     assert_func(result2, exp)
+
+
+@pytest.mark.parametrize('years,months', product([-1, 0, 1], [-2, 0, 2]))
+def test_shift_months(years, months):
+    s = DatetimeIndex([Timestamp('2000-01-05 00:15:00'),
+                       Timestamp('2000-01-31 00:23:00'),
+                       Timestamp('2000-01-01'),
+                       Timestamp('2000-02-29'),
+                       Timestamp('2000-12-31')])
+    actual = DatetimeIndex(shift_months(s.asi8, years * 12 + months))
+    expected = DatetimeIndex([x + pd.offsets.DateOffset(
+        years=years, months=months) for x in s])
+    tm.assert_index_equal(actual, expected)
diff --git a/pandas/tests/indexes/datetimes/test_astype.py b/pandas/tests/indexes/datetimes/test_astype.py
index 4b989eb35e900..2f2d89a3cb638 100644
--- a/pandas/tests/indexes/datetimes/test_astype.py
+++ b/pandas/tests/indexes/datetimes/test_astype.py
@@ -138,6 +138,48 @@ def test_astype_object(self):
         tm.assert_index_equal(casted, Index(exp_values, dtype=np.object_))
         assert casted.tolist() == exp_values
 
+        idx = pd.date_range(start='2013-01-01', periods=4, freq='M',
+                            name='idx')
+        expected_list = [Timestamp('2013-01-31'),
+                         Timestamp('2013-02-28'),
+                         Timestamp('2013-03-31'),
+                         Timestamp('2013-04-30')]
+        expected = pd.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)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
+
+        idx = pd.date_range(start='2013-01-01', periods=4, freq='M',
+                            name='idx', tz='Asia/Tokyo')
+        expected_list = [Timestamp('2013-01-31', tz='Asia/Tokyo'),
+                         Timestamp('2013-02-28', tz='Asia/Tokyo'),
+                         Timestamp('2013-03-31', tz='Asia/Tokyo'),
+                         Timestamp('2013-04-30', tz='Asia/Tokyo')]
+        expected = pd.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)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
+
+        idx = DatetimeIndex([datetime(2013, 1, 1), datetime(2013, 1, 2),
+                             pd.NaT, datetime(2013, 1, 4)], name='idx')
+        expected_list = [Timestamp('2013-01-01'),
+                         Timestamp('2013-01-02'), pd.NaT,
+                         Timestamp('2013-01-04')]
+        expected = pd.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)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
+
     @pytest.mark.parametrize('dtype', [
         float, 'timedelta64', 'timedelta64[ns]', 'datetime64',
         'datetime64[D]'])
diff --git a/pandas/tests/indexes/datetimes/test_ops.py b/pandas/tests/indexes/datetimes/test_ops.py
index 4f386eb28cc0f..bc43b427fe0aa 100644
--- a/pandas/tests/indexes/datetimes/test_ops.py
+++ b/pandas/tests/indexes/datetimes/test_ops.py
@@ -5,10 +5,8 @@
 import numpy as np
 from datetime import datetime
 
-from itertools import product
 import pandas as pd
 import pandas._libs.tslib as tslib
-from pandas._libs.tslibs.offsets import shift_months
 import pandas.util.testing as tm
 from pandas import (DatetimeIndex, PeriodIndex, Series, Timestamp,
                     date_range, _np_version_under1p10, Index,
@@ -51,49 +49,6 @@ def test_ops_properties_basic(self):
         assert s.day == 10
         pytest.raises(AttributeError, lambda: s.weekday)
 
-    def test_astype_object(self):
-        idx = pd.date_range(start='2013-01-01', periods=4, freq='M',
-                            name='idx')
-        expected_list = [Timestamp('2013-01-31'),
-                         Timestamp('2013-02-28'),
-                         Timestamp('2013-03-31'),
-                         Timestamp('2013-04-30')]
-        expected = pd.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)
-        assert result.name == expected.name
-        assert idx.tolist() == expected_list
-
-        idx = pd.date_range(start='2013-01-01', periods=4, freq='M',
-                            name='idx', tz='Asia/Tokyo')
-        expected_list = [Timestamp('2013-01-31', tz='Asia/Tokyo'),
-                         Timestamp('2013-02-28', tz='Asia/Tokyo'),
-                         Timestamp('2013-03-31', tz='Asia/Tokyo'),
-                         Timestamp('2013-04-30', tz='Asia/Tokyo')]
-        expected = pd.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)
-        assert result.name == expected.name
-        assert idx.tolist() == expected_list
-
-        idx = DatetimeIndex([datetime(2013, 1, 1), datetime(2013, 1, 2),
-                             pd.NaT, datetime(2013, 1, 4)], name='idx')
-        expected_list = [Timestamp('2013-01-01'),
-                         Timestamp('2013-01-02'), pd.NaT,
-                         Timestamp('2013-01-04')]
-        expected = pd.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)
-        assert result.name == expected.name
-        assert idx.tolist() == expected_list
-
     def test_minmax(self):
         for tz in self.tz:
             # monotonic
@@ -568,19 +523,6 @@ def test_equals(self):
             assert not idx.equals(pd.Series(idx3))
 
 
-@pytest.mark.parametrize('years,months', product([-1, 0, 1], [-2, 0, 2]))
-def test_shift_months(years, months):
-    s = DatetimeIndex([Timestamp('2000-01-05 00:15:00'),
-                       Timestamp('2000-01-31 00:23:00'),
-                       Timestamp('2000-01-01'),
-                       Timestamp('2000-02-29'),
-                       Timestamp('2000-12-31')])
-    actual = DatetimeIndex(shift_months(s.asi8, years * 12 + months))
-    expected = DatetimeIndex([x + pd.offsets.DateOffset(
-        years=years, months=months) for x in s])
-    tm.assert_index_equal(actual, expected)
-
-
 class TestBusinessDatetimeIndex(object):
 
     def setup_method(self, method):
diff --git a/pandas/tests/indexes/datetimes/test_tools.py b/pandas/tests/indexes/datetimes/test_tools.py
index f8b1f68ba33ce..78cdf9df2b0d0 100644
--- a/pandas/tests/indexes/datetimes/test_tools.py
+++ b/pandas/tests/indexes/datetimes/test_tools.py
@@ -8,7 +8,7 @@
 import dateutil
 import numpy as np
 from dateutil.parser import parse
-from datetime import datetime, date, time
+from datetime import datetime, time
 from distutils.version import LooseVersion
 
 import pandas as pd
@@ -19,7 +19,6 @@
 
 from pandas.errors import OutOfBoundsDatetime
 from pandas.compat import lmap
-from pandas.compat.numpy import np_array_datetime64_compat
 from pandas.core.dtypes.common import is_datetime64_ns_dtype
 from pandas.util import testing as tm
 import pandas.util._test_decorators as td
@@ -1445,182 +1444,15 @@ def test_parsers_timezone_minute_offsets_roundtrip(self, cache):
             converted_time = dt_time.tz_localize('UTC').tz_convert(tz)
             assert dt_string_repr == repr(converted_time)
 
-    def test_parsers_iso8601(self):
-        # GH 12060
-        # test only the iso parser - flexibility to different
-        # separators and leadings 0s
-        # Timestamp construction falls back to dateutil
-        cases = {'2011-01-02': datetime(2011, 1, 2),
-                 '2011-1-2': datetime(2011, 1, 2),
-                 '2011-01': datetime(2011, 1, 1),
-                 '2011-1': datetime(2011, 1, 1),
-                 '2011 01 02': datetime(2011, 1, 2),
-                 '2011.01.02': datetime(2011, 1, 2),
-                 '2011/01/02': datetime(2011, 1, 2),
-                 '2011\\01\\02': datetime(2011, 1, 2),
-                 '2013-01-01 05:30:00': datetime(2013, 1, 1, 5, 30),
-                 '2013-1-1 5:30:00': datetime(2013, 1, 1, 5, 30)}
-        for date_str, exp in compat.iteritems(cases):
-            actual = tslib._test_parse_iso8601(date_str)
-            assert actual == exp
-
-        # separators must all match - YYYYMM not valid
-        invalid_cases = ['2011-01/02', '2011^11^11',
-                         '201401', '201111', '200101',
-                         # mixed separated and unseparated
-                         '2005-0101', '200501-01',
-                         '20010101 12:3456', '20010101 1234:56',
-                         # HHMMSS must have two digits in each component
-                         # if unseparated
-                         '20010101 1', '20010101 123', '20010101 12345',
-                         '20010101 12345Z',
-                         # wrong separator for HHMMSS
-                         '2001-01-01 12-34-56']
-        for date_str in invalid_cases:
-            with pytest.raises(ValueError):
-                tslib._test_parse_iso8601(date_str)
-                # If no ValueError raised, let me know which case failed.
-                raise Exception(date_str)
-
-
-class TestArrayToDatetime(object):
-    def test_parsing_valid_dates(self):
-        arr = np.array(['01-01-2013', '01-02-2013'], dtype=object)
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr),
-            np_array_datetime64_compat(
-                [
-                    '2013-01-01T00:00:00.000000000-0000',
-                    '2013-01-02T00:00:00.000000000-0000'
-                ],
-                dtype='M8[ns]'
-            )
-        )
-
-        arr = np.array(['Mon Sep 16 2013', 'Tue Sep 17 2013'], dtype=object)
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr),
-            np_array_datetime64_compat(
-                [
-                    '2013-09-16T00:00:00.000000000-0000',
-                    '2013-09-17T00:00:00.000000000-0000'
-                ],
-                dtype='M8[ns]'
-            )
-        )
-
-    def test_parsing_timezone_offsets(self):
-        # All of these datetime strings with offsets are equivalent
-        # to the same datetime after the timezone offset is added
-        dt_strings = [
-            '01-01-2013 08:00:00+08:00',
-            '2013-01-01T08:00:00.000000000+0800',
-            '2012-12-31T16:00:00.000000000-0800',
-            '12-31-2012 23:00:00-01:00'
-        ]
-
-        expected_output = tslib.array_to_datetime(np.array(
-            ['01-01-2013 00:00:00'], dtype=object))
-
-        for dt_string in dt_strings:
-            tm.assert_numpy_array_equal(
-                tslib.array_to_datetime(
-                    np.array([dt_string], dtype=object)
-                ),
-                expected_output
-            )
-
-    def test_number_looking_strings_not_into_datetime(self):
-        # #4601
-        # These strings don't look like datetimes so they shouldn't be
-        # attempted to be converted
-        arr = np.array(['-352.737091', '183.575577'], dtype=object)
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr, errors='ignore'), arr)
-
-        arr = np.array(['1', '2', '3', '4', '5'], dtype=object)
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr, errors='ignore'), arr)
-
-    def test_coercing_dates_outside_of_datetime64_ns_bounds(self):
-        invalid_dates = [
-            date(1000, 1, 1),
-            datetime(1000, 1, 1),
-            '1000-01-01',
-            'Jan 1, 1000',
-            np.datetime64('1000-01-01'),
-        ]
-
-        for invalid_date in invalid_dates:
-            pytest.raises(ValueError,
-                          tslib.array_to_datetime,
-                          np.array([invalid_date], dtype='object'),
-                          errors='raise', )
-            tm.assert_numpy_array_equal(
-                tslib.array_to_datetime(
-                    np.array([invalid_date], dtype='object'),
-                    errors='coerce'),
-                np.array([tslib.iNaT], dtype='M8[ns]')
-            )
 
-        arr = np.array(['1/1/1000', '1/1/2000'], dtype=object)
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr, errors='coerce'),
-            np_array_datetime64_compat(
-                [
-                    tslib.iNaT,
-                    '2000-01-01T00:00:00.000000000-0000'
-                ],
-                dtype='M8[ns]'
-            )
-        )
-
-    def test_coerce_of_invalid_datetimes(self):
-        arr = np.array(['01-01-2013', 'not_a_date', '1'], dtype=object)
+def test_to_datetime_barely_out_of_bounds(self):
+    # GH#19529
+    # GH#19382 close enough to bounds that dropping nanos would result
+    # in an in-bounds datetime
+    arr = np.array(['2262-04-11 23:47:16.854775808'], dtype=object)
 
-        # Without coercing, the presence of any invalid dates prevents
-        # any values from being converted
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr, errors='ignore'), arr)
-
-        # With coercing, the invalid dates becomes iNaT
-        tm.assert_numpy_array_equal(
-            tslib.array_to_datetime(arr, errors='coerce'),
-            np_array_datetime64_compat(
-                [
-                    '2013-01-01T00:00:00.000000000-0000',
-                    tslib.iNaT,
-                    tslib.iNaT
-                ],
-                dtype='M8[ns]'
-            )
-        )
-
-    def test_to_datetime_barely_out_of_bounds(self):
-        # GH#19529
-        # GH#19382 close enough to bounds that dropping nanos would result
-        # in an in-bounds datetime
-        arr = np.array(['2262-04-11 23:47:16.854775808'], dtype=object)
-
-        with pytest.raises(OutOfBoundsDatetime):
-            to_datetime(arr)
-
-        with pytest.raises(OutOfBoundsDatetime):
-            # Essentially the same as above, but more directly calling
-            # the relevant function
-            tslib.array_to_datetime(arr)
-
-
-def test_normalize_date():
-    value = date(2012, 9, 7)
-
-    result = tslib.normalize_date(value)
-    assert (result == datetime(2012, 9, 7))
-
-    value = datetime(2012, 9, 7, 12)
-
-    result = tslib.normalize_date(value)
-    assert (result == datetime(2012, 9, 7))
+    with pytest.raises(OutOfBoundsDatetime):
+        to_datetime(arr)
 
 
 @pytest.fixture(params=['D', 's', 'ms', 'us', 'ns'])
@@ -1745,3 +1577,15 @@ def test_processing_order(self):
         result = pd.to_datetime(300 * 365, unit='D', origin='1870-01-01')
         expected = Timestamp('2169-10-20 00:00:00')
         assert result == expected
+
+
+def test_to_datetime1():
+    actual = pd.to_datetime(datetime(2008, 1, 15))
+    assert actual == datetime(2008, 1, 15)
+
+    actual = pd.to_datetime('20080115')
+    assert actual == datetime(2008, 1, 15)
+
+    # unparseable
+    s = 'Month 1, 1999'
+    assert pd.to_datetime(s, errors='ignore') == s
diff --git a/pandas/tests/indexes/period/test_arithmetic.py b/pandas/tests/indexes/period/test_arithmetic.py
index 356ea5fc656de..9476359e3b4f4 100644
--- a/pandas/tests/indexes/period/test_arithmetic.py
+++ b/pandas/tests/indexes/period/test_arithmetic.py
@@ -250,6 +250,79 @@ def test_sub_isub(self):
         rng -= 1
         tm.assert_index_equal(rng, expected)
 
+    # ------------------------------------------------------------------
+    # PeriodIndex.shift is used by __add__ and __sub__
+
+    def test_shift(self):
+        pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='A', start='1/1/2002', end='12/1/2010')
+
+        tm.assert_index_equal(pi1.shift(0), pi1)
+
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='A', start='1/1/2000', end='12/1/2008')
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+        pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='M', start='2/1/2001', end='1/1/2010')
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='M', start='12/1/2000', end='11/1/2009')
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+        pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='D', start='1/2/2001', end='12/2/2009')
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(1), pi2)
+
+        pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
+        pi2 = PeriodIndex(freq='D', start='12/31/2000', end='11/30/2009')
+        assert len(pi1) == len(pi2)
+        tm.assert_index_equal(pi1.shift(-1), pi2)
+
+    def test_shift_ndarray(self):
+        idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
+                           '2011-04'], freq='M', name='idx')
+        result = idx.shift(np.array([1, 2, 3, 4]))
+        expected = PeriodIndex(['2011-02', '2011-04', 'NaT',
+                                '2011-08'], freq='M', name='idx')
+        tm.assert_index_equal(result, expected)
+
+        idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
+                           '2011-04'], freq='M', name='idx')
+        result = idx.shift(np.array([1, -2, 3, -4]))
+        expected = PeriodIndex(['2011-02', '2010-12', 'NaT',
+                                '2010-12'], freq='M', name='idx')
+        tm.assert_index_equal(result, expected)
+
+    def test_shift_corner_cases(self):
+        # GH#9903
+        idx = PeriodIndex([], name='xxx', freq='H')
+
+        with pytest.raises(TypeError):
+            # period shift doesn't accept freq
+            idx.shift(1, freq='H')
+
+        tm.assert_index_equal(idx.shift(0), idx)
+        tm.assert_index_equal(idx.shift(3), idx)
+
+        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 = 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 = PeriodIndex(['2011-01-01 07:00', '2011-01-01 08:00'
+                           '2011-01-01 09:00'], name='xxx', freq='H')
+        tm.assert_index_equal(idx.shift(-3), exp)
+
 
 class TestPeriodIndexSeriesMethods(object):
     """ Test PeriodIndex and Period Series Ops consistency """
diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py
index 21a9ffdde3444..9db6618018eb3 100644
--- a/pandas/tests/indexes/period/test_ops.py
+++ b/pandas/tests/indexes/period/test_ops.py
@@ -520,27 +520,6 @@ def test_nat_new(self):
         exp = np.array([tslib.iNaT] * 5, dtype=np.int64)
         tm.assert_numpy_array_equal(result, exp)
 
-    def test_shift(self):
-        # GH 9903
-        idx = pd.PeriodIndex([], name='xxx', freq='H')
-
-        with pytest.raises(TypeError):
-            # period shift doesn't accept freq
-            idx.shift(1, freq='H')
-
-        tm.assert_index_equal(idx.shift(0), idx)
-        tm.assert_index_equal(idx.shift(3), idx)
-
-        idx = pd.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(['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(['2011-01-01 07:00', '2011-01-01 08:00'
-                              '2011-01-01 09:00'], name='xxx', freq='H')
-        tm.assert_index_equal(idx.shift(-3), exp)
-
     def test_repeat(self):
         index = pd.period_range('2001-01-01', periods=2, freq='D')
         exp = pd.PeriodIndex(['2001-01-01', '2001-01-01',
diff --git a/pandas/tests/indexes/period/test_period.py b/pandas/tests/indexes/period/test_period.py
index 6fc7fa5486f82..e5e9527a6a8e9 100644
--- a/pandas/tests/indexes/period/test_period.py
+++ b/pandas/tests/indexes/period/test_period.py
@@ -453,16 +453,6 @@ def test_periods_number_check(self):
         with pytest.raises(ValueError):
             period_range('2011-1-1', '2012-1-1', 'B')
 
-    def test_start_time(self):
-        index = PeriodIndex(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):
-        index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
-        expected_index = date_range('2016-01-01', end='2016-05-31', freq='M')
-        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')
@@ -505,40 +495,6 @@ def test_shift_gh8083(self):
                                 '2013-01-05', '2013-01-06'], freq='D')
         tm.assert_index_equal(result, expected)
 
-    def test_shift(self):
-        pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='A', start='1/1/2002', end='12/1/2010')
-
-        tm.assert_index_equal(pi1.shift(0), pi1)
-
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(1), pi2)
-
-        pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='A', start='1/1/2000', end='12/1/2008')
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(-1), pi2)
-
-        pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='M', start='2/1/2001', end='1/1/2010')
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(1), pi2)
-
-        pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='M', start='12/1/2000', end='11/1/2009')
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(-1), pi2)
-
-        pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='D', start='1/2/2001', end='12/2/2009')
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(1), pi2)
-
-        pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
-        pi2 = PeriodIndex(freq='D', start='12/31/2000', end='11/30/2009')
-        assert len(pi1) == len(pi2)
-        tm.assert_index_equal(pi1.shift(-1), pi2)
-
     def test_shift_nat(self):
         idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
                            '2011-04'], freq='M', name='idx')
@@ -552,21 +508,6 @@ def test_shift_nat(self):
     def test_ndarray_compat_properties(self):
         super(TestPeriodIndex, self).test_ndarray_compat_properties()
 
-    def test_shift_ndarray(self):
-        idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
-                           '2011-04'], freq='M', name='idx')
-        result = idx.shift(np.array([1, 2, 3, 4]))
-        expected = PeriodIndex(['2011-02', '2011-04', 'NaT',
-                                '2011-08'], freq='M', name='idx')
-        tm.assert_index_equal(result, expected)
-
-        idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
-                           '2011-04'], freq='M', name='idx')
-        result = idx.shift(np.array([1, -2, 3, -4]))
-        expected = PeriodIndex(['2011-02', '2010-12', 'NaT',
-                                '2010-12'], freq='M', name='idx')
-        tm.assert_index_equal(result, expected)
-
     def test_negative_ordinals(self):
         Period(ordinal=-1000, freq='A')
         Period(ordinal=0, freq='A')
diff --git a/pandas/tests/indexes/period/test_scalar_compat.py b/pandas/tests/indexes/period/test_scalar_compat.py
new file mode 100644
index 0000000000000..56bd2adf58719
--- /dev/null
+++ b/pandas/tests/indexes/period/test_scalar_compat.py
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""Tests for PeriodIndex behaving like a vectorized Period scalar"""
+
+from pandas import PeriodIndex, date_range
+import pandas.util.testing as tm
+
+
+class TestPeriodIndexOps(object):
+    def test_start_time(self):
+        index = PeriodIndex(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):
+        index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
+        expected_index = date_range('2016-01-01', end='2016-05-31', freq='M')
+        tm.assert_index_equal(index.end_time, expected_index)
diff --git a/pandas/tests/indexes/period/test_tools.py b/pandas/tests/indexes/period/test_tools.py
index 0e72cadb5d494..f5e7c8269dc4f 100644
--- a/pandas/tests/indexes/period/test_tools.py
+++ b/pandas/tests/indexes/period/test_tools.py
@@ -6,8 +6,6 @@
 import pandas.core.indexes.period as period
 from pandas.compat import lrange
 
-from pandas._libs.tslibs.frequencies import get_freq
-from pandas._libs.tslibs.period import period_ordinal, period_asfreq
 from pandas._libs.tslibs.ccalendar import MONTHS
 
 from pandas import (PeriodIndex, Period, DatetimeIndex, Timestamp, Series,
@@ -76,83 +74,6 @@ def test_negone_ordinals(self):
         repr(period)
 
 
-class TestTslib(object):
-    def test_intraday_conversion_factors(self):
-        assert period_asfreq(1, get_freq('D'), get_freq('H'), False) == 24
-        assert period_asfreq(1, get_freq('D'), get_freq('T'), False) == 1440
-        assert period_asfreq(1, get_freq('D'), get_freq('S'), False) == 86400
-        assert period_asfreq(1, get_freq('D'),
-                             get_freq('L'), False) == 86400000
-        assert period_asfreq(1, get_freq('D'),
-                             get_freq('U'), False) == 86400000000
-        assert period_asfreq(1, get_freq('D'),
-                             get_freq('N'), False) == 86400000000000
-
-        assert period_asfreq(1, get_freq('H'), get_freq('T'), False) == 60
-        assert period_asfreq(1, get_freq('H'), get_freq('S'), False) == 3600
-        assert period_asfreq(1, get_freq('H'),
-                             get_freq('L'), False) == 3600000
-        assert period_asfreq(1, get_freq('H'),
-                             get_freq('U'), False) == 3600000000
-        assert period_asfreq(1, get_freq('H'),
-                             get_freq('N'), False) == 3600000000000
-
-        assert period_asfreq(1, get_freq('T'), get_freq('S'), False) == 60
-        assert period_asfreq(1, get_freq('T'), get_freq('L'), False) == 60000
-        assert period_asfreq(1, get_freq('T'),
-                             get_freq('U'), False) == 60000000
-        assert period_asfreq(1, get_freq('T'),
-                             get_freq('N'), False) == 60000000000
-
-        assert period_asfreq(1, get_freq('S'), get_freq('L'), False) == 1000
-        assert period_asfreq(1, get_freq('S'),
-                             get_freq('U'), False) == 1000000
-        assert period_asfreq(1, get_freq('S'),
-                             get_freq('N'), False) == 1000000000
-
-        assert period_asfreq(1, get_freq('L'), get_freq('U'), False) == 1000
-        assert period_asfreq(1, get_freq('L'),
-                             get_freq('N'), False) == 1000000
-
-        assert period_asfreq(1, get_freq('U'), get_freq('N'), False) == 1000
-
-    def test_period_ordinal_start_values(self):
-        # information for 1.1.1970
-        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('A')) == 0
-        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')) == 0
-        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')) == 1
-        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')) == 0
-        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')) == 0
-
-    def test_period_ordinal_week(self):
-        assert period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0, get_freq('W')) == 1
-        assert period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0, get_freq('W')) == 2
-        assert period_ordinal(2013, 10, 6, 0,
-                              0, 0, 0, 0, get_freq('W')) == 2284
-        assert period_ordinal(2013, 10, 7, 0,
-                              0, 0, 0, 0, get_freq('W')) == 2285
-
-    def test_period_ordinal_business_day(self):
-        # Thursday
-        assert period_ordinal(2013, 10, 3, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11415
-        # Friday
-        assert period_ordinal(2013, 10, 4, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11416
-        # Saturday
-        assert period_ordinal(2013, 10, 5, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11417
-        # Sunday
-        assert period_ordinal(2013, 10, 6, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11417
-        # Monday
-        assert period_ordinal(2013, 10, 7, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11417
-        # Tuesday
-        assert period_ordinal(2013, 10, 8, 0,
-                              0, 0, 0, 0, get_freq('B')) == 11418
-
-
 class TestPeriodIndex(object):
 
     def setup_method(self, method):
diff --git a/pandas/tests/indexes/timedeltas/test_astype.py b/pandas/tests/indexes/timedeltas/test_astype.py
index 6c644d239069a..2197c172e3056 100644
--- a/pandas/tests/indexes/timedeltas/test_astype.py
+++ b/pandas/tests/indexes/timedeltas/test_astype.py
@@ -1,3 +1,4 @@
+from datetime import timedelta
 import pytest
 
 import numpy as np
@@ -8,6 +9,30 @@
 
 
 class TestTimedeltaIndex(object):
+    def test_astype_object(self):
+        idx = timedelta_range(start='1 days', periods=4, freq='D', name='idx')
+        expected_list = [Timedelta('1 days'), Timedelta('2 days'),
+                         Timedelta('3 days'), Timedelta('4 days')]
+        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)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
+
+        idx = TimedeltaIndex([timedelta(days=1), timedelta(days=2), NaT,
+                              timedelta(days=4)], name='idx')
+        expected_list = [Timedelta('1 days'), Timedelta('2 days'), NaT,
+                         Timedelta('4 days')]
+        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)
+        assert result.name == expected.name
+        assert idx.tolist() == expected_list
 
     def test_astype(self):
         # GH 13149, GH 13209
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index 86d7dd4e1b117..d154aa2172ef7 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -8,7 +8,7 @@
 from pandas import to_timedelta
 from pandas import (Series, Timedelta, Timestamp, TimedeltaIndex,
                     timedelta_range,
-                    _np_version_under1p10, Index)
+                    _np_version_under1p10)
 from pandas._libs.tslib import iNaT
 from pandas.tests.test_base import Ops
 
@@ -25,31 +25,6 @@ def test_ops_properties(self):
         self.check_ops_properties(TimedeltaIndex._field_ops, f)
         self.check_ops_properties(TimedeltaIndex._object_ops, f)
 
-    def test_astype_object(self):
-        idx = timedelta_range(start='1 days', periods=4, freq='D', name='idx')
-        expected_list = [Timedelta('1 days'), Timedelta('2 days'),
-                         Timedelta('3 days'), Timedelta('4 days')]
-        expected = pd.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)
-        assert result.name == expected.name
-        assert idx.tolist() == expected_list
-
-        idx = TimedeltaIndex([timedelta(days=1), timedelta(days=2), pd.NaT,
-                              timedelta(days=4)], name='idx')
-        expected_list = [Timedelta('1 days'), Timedelta('2 days'), pd.NaT,
-                         Timedelta('4 days')]
-        expected = pd.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)
-        assert result.name == expected.name
-        assert idx.tolist() == expected_list
-
     def test_minmax(self):
 
         # monotonic
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index d96ebab615d12..31738097b1e48 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -33,7 +33,7 @@
 import pandas.tseries.offsets as offsets
 from pandas.io.pickle import read_pickle
 from pandas._libs.tslibs import timezones
-from pandas._libs.tslib import normalize_date, NaT, Timestamp
+from pandas._libs.tslib import NaT, Timestamp
 import pandas._libs.tslib as tslib
 import pandas.util.testing as tm
 from pandas.tseries.holiday import USFederalHolidayCalendar
@@ -41,12 +41,6 @@
 from .common import assert_offset_equal, assert_onOffset
 
 
-def test_monthrange():
-    import calendar
-    for y in range(2000, 2013):
-        for m in range(1, 13):
-            assert tslib.monthrange(y, m) == calendar.monthrange(y, m)
-
 ####
 # Misc function tests
 ####
@@ -65,11 +59,6 @@ def test_ole2datetime():
         ole2datetime(60)
 
 
-def test_normalize_date():
-    actual = normalize_date(datetime(2007, 10, 1, 1, 12, 5, 10))
-    assert actual == datetime(2007, 10, 1)
-
-
 def test_to_m8():
     valb = datetime(2007, 10, 1)
     valu = _to_m8(valb)
diff --git a/pandas/tests/tseries/test_timezones.py b/pandas/tests/tseries/test_timezones.py
index 565e735c14c80..e5e5ddc7a0059 100644
--- a/pandas/tests/tseries/test_timezones.py
+++ b/pandas/tests/tseries/test_timezones.py
@@ -3,14 +3,10 @@
 
 import pytz
 import dateutil
-import numpy as np
 
 from datetime import datetime
 
-import pandas.util.testing as tm
-from pandas.core.indexes.datetimes import date_range
-from pandas._libs import tslib
-from pandas._libs.tslibs import timezones, conversion
+from pandas._libs.tslibs import timezones
 from pandas import Timestamp
 
 
@@ -111,82 +107,3 @@ def localize(self, tz, x):
     def normalize(self, ts):
         # no-op for dateutil
         return ts
-
-    def test_tzlocal(self):
-        # GH 13583
-        ts = Timestamp('2011-01-01', tz=dateutil.tz.tzlocal())
-        assert ts.tz == dateutil.tz.tzlocal()
-        assert "tz='tzlocal()')" in repr(ts)
-
-        tz = timezones.maybe_get_tz('tzlocal()')
-        assert tz == dateutil.tz.tzlocal()
-
-        # get offset using normal datetime for test
-        offset = dateutil.tz.tzlocal().utcoffset(datetime(2011, 1, 1))
-        offset = offset.total_seconds() * 1000000000
-        assert ts.value + offset == Timestamp('2011-01-01').value
-
-
-class TestTimeZoneCacheKey(object):
-
-    @pytest.mark.parametrize('tz_name', list(pytz.common_timezones))
-    def test_cache_keys_are_distinct_for_pytz_vs_dateutil(self, tz_name):
-        if tz_name == 'UTC':
-            # skip utc as it's a special case in dateutil
-            return
-        tz_p = timezones.maybe_get_tz(tz_name)
-        tz_d = timezones.maybe_get_tz('dateutil/' + tz_name)
-        if tz_d is None:
-            # skip timezones that dateutil doesn't know about.
-            return
-        assert (timezones._p_tz_cache_key(tz_p) !=
-                timezones._p_tz_cache_key(tz_d))
-
-
-class TestTslib(object):
-
-    def test_tslib_tz_convert(self):
-        def compare_utc_to_local(tz_didx, utc_didx):
-            f = lambda x: conversion.tz_convert_single(x, 'UTC', tz_didx.tz)
-            result = conversion.tz_convert(tz_didx.asi8, 'UTC', tz_didx.tz)
-            result_single = np.vectorize(f)(tz_didx.asi8)
-            tm.assert_numpy_array_equal(result, result_single)
-
-        def compare_local_to_utc(tz_didx, utc_didx):
-            f = lambda x: conversion.tz_convert_single(x, tz_didx.tz, 'UTC')
-            result = conversion.tz_convert(utc_didx.asi8, tz_didx.tz, 'UTC')
-            result_single = np.vectorize(f)(utc_didx.asi8)
-            tm.assert_numpy_array_equal(result, result_single)
-
-        for tz in ['UTC', 'Asia/Tokyo', 'US/Eastern', 'Europe/Moscow']:
-            # US: 2014-03-09 - 2014-11-11
-            # MOSCOW: 2014-10-26  /  2014-12-31
-            tz_didx = date_range('2014-03-01', '2015-01-10', freq='H', tz=tz)
-            utc_didx = date_range('2014-03-01', '2015-01-10', freq='H')
-            compare_utc_to_local(tz_didx, utc_didx)
-            # local tz to UTC can be differ in hourly (or higher) freqs because
-            # of DST
-            compare_local_to_utc(tz_didx, utc_didx)
-
-            tz_didx = date_range('2000-01-01', '2020-01-01', freq='D', tz=tz)
-            utc_didx = date_range('2000-01-01', '2020-01-01', freq='D')
-            compare_utc_to_local(tz_didx, utc_didx)
-            compare_local_to_utc(tz_didx, utc_didx)
-
-            tz_didx = date_range('2000-01-01', '2100-01-01', freq='A', tz=tz)
-            utc_didx = date_range('2000-01-01', '2100-01-01', freq='A')
-            compare_utc_to_local(tz_didx, utc_didx)
-            compare_local_to_utc(tz_didx, utc_didx)
-
-        # Check empty array
-        result = conversion.tz_convert(np.array([], dtype=np.int64),
-                                       timezones.maybe_get_tz('US/Eastern'),
-                                       timezones.maybe_get_tz('Asia/Tokyo'))
-        tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
-
-        # Check all-NaT array
-        result = conversion.tz_convert(np.array([tslib.iNaT], dtype=np.int64),
-                                       timezones.maybe_get_tz('US/Eastern'),
-                                       timezones.maybe_get_tz('Asia/Tokyo'))
-        tm.assert_numpy_array_equal(result, np.array(
-            [tslib.iNaT], dtype=np.int64))
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
new file mode 100644
index 0000000000000..0bb4d738e2844
--- /dev/null
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import pytest
+
+import pandas.util.testing as tm
+from pandas import date_range
+from pandas._libs.tslib import iNaT
+from pandas._libs.tslibs import conversion, timezones
+
+
+class TestTslib(object):
+
+    @pytest.mark.parametrize('tz', ['UTC', 'Asia/Tokyo',
+                                    'US/Eastern', 'Europe/Moscow'])
+    def test_tslib_tz_convert(self, tz):
+        def compare_utc_to_local(tz_didx, utc_didx):
+            f = lambda x: conversion.tz_convert_single(x, 'UTC', tz_didx.tz)
+            result = conversion.tz_convert(tz_didx.asi8, 'UTC', tz_didx.tz)
+            result_single = np.vectorize(f)(tz_didx.asi8)
+            tm.assert_numpy_array_equal(result, result_single)
+
+        def compare_local_to_utc(tz_didx, utc_didx):
+            f = lambda x: conversion.tz_convert_single(x, tz_didx.tz, 'UTC')
+            result = conversion.tz_convert(utc_didx.asi8, tz_didx.tz, 'UTC')
+            result_single = np.vectorize(f)(utc_didx.asi8)
+            tm.assert_numpy_array_equal(result, result_single)
+
+        # US: 2014-03-09 - 2014-11-11
+        # MOSCOW: 2014-10-26  /  2014-12-31
+        tz_didx = date_range('2014-03-01', '2015-01-10', freq='H', tz=tz)
+        utc_didx = date_range('2014-03-01', '2015-01-10', freq='H')
+        compare_utc_to_local(tz_didx, utc_didx)
+        # local tz to UTC can be differ in hourly (or higher) freqs because
+        # of DST
+        compare_local_to_utc(tz_didx, utc_didx)
+
+        tz_didx = date_range('2000-01-01', '2020-01-01', freq='D', tz=tz)
+        utc_didx = date_range('2000-01-01', '2020-01-01', freq='D')
+        compare_utc_to_local(tz_didx, utc_didx)
+        compare_local_to_utc(tz_didx, utc_didx)
+
+        tz_didx = date_range('2000-01-01', '2100-01-01', freq='A', tz=tz)
+        utc_didx = date_range('2000-01-01', '2100-01-01', freq='A')
+        compare_utc_to_local(tz_didx, utc_didx)
+        compare_local_to_utc(tz_didx, utc_didx)
+
+    def test_tz_convert_empty(self):
+        # Check empty array
+        arr = np.array([], dtype=np.int64)
+        result = conversion.tz_convert(arr,
+                                       timezones.maybe_get_tz('US/Eastern'),
+                                       timezones.maybe_get_tz('Asia/Tokyo'))
+        tm.assert_numpy_array_equal(result, arr)
+
+    def test_tz_convert_nat(self):
+        # Check all-NaT array
+        arr = np.array([iNaT], dtype=np.int64)
+        result = conversion.tz_convert(arr,
+                                       timezones.maybe_get_tz('US/Eastern'),
+                                       timezones.maybe_get_tz('Asia/Tokyo'))
+        tm.assert_numpy_array_equal(result, arr)
diff --git a/pandas/tests/tseries/test_libfrequencies.py b/pandas/tests/tslibs/test_libfrequencies.py
similarity index 100%
rename from pandas/tests/tseries/test_libfrequencies.py
rename to pandas/tests/tslibs/test_libfrequencies.py
diff --git a/pandas/tests/tseries/offsets/test_liboffsets.py b/pandas/tests/tslibs/test_liboffsets.py
similarity index 100%
rename from pandas/tests/tseries/offsets/test_liboffsets.py
rename to pandas/tests/tslibs/test_liboffsets.py
diff --git a/pandas/tests/scalar/test_parsing.py b/pandas/tests/tslibs/test_parsing.py
similarity index 96%
rename from pandas/tests/scalar/test_parsing.py
rename to pandas/tests/tslibs/test_parsing.py
index bff0de649ac5e..f95f165ce82f5 100644
--- a/pandas/tests/scalar/test_parsing.py
+++ b/pandas/tests/tslibs/test_parsing.py
@@ -3,11 +3,11 @@
 Tests for Timestamp parsing, aimed at pandas/_libs/tslibs/parsing.pyx
 """
 from datetime import datetime
+
 import numpy as np
 import pytest
 from dateutil.parser import parse
 
-import pandas as pd
 import pandas.util._test_decorators as td
 from pandas.conftest import is_dateutil_le_261, is_dateutil_gt_261
 from pandas import compat
@@ -16,18 +16,6 @@
 from pandas._libs.tslibs.parsing import parse_time_string
 
 
-def test_to_datetime1():
-    actual = pd.to_datetime(datetime(2008, 1, 15))
-    assert actual == datetime(2008, 1, 15)
-
-    actual = pd.to_datetime('20080115')
-    assert actual == datetime(2008, 1, 15)
-
-    # unparseable
-    s = 'Month 1, 1999'
-    assert pd.to_datetime(s, errors='ignore') == s
-
-
 class TestParseQuarters(object):
 
     def test_parse_time_string(self):
diff --git a/pandas/tests/tslibs/test_period_helper.py b/pandas/tests/tslibs/test_period_helper.py
new file mode 100644
index 0000000000000..98959adf6fda4
--- /dev/null
+++ b/pandas/tests/tslibs/test_period_helper.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+from pandas._libs.tslibs.frequencies import get_freq
+from pandas._libs.tslibs.period import period_ordinal, period_asfreq
+
+
+class TestPeriodFreqConversion(object):
+    def test_intraday_conversion_factors(self):
+        assert period_asfreq(1, get_freq('D'), get_freq('H'), False) == 24
+        assert period_asfreq(1, get_freq('D'), get_freq('T'), False) == 1440
+        assert period_asfreq(1, get_freq('D'), get_freq('S'), False) == 86400
+        assert period_asfreq(1, get_freq('D'),
+                             get_freq('L'), False) == 86400000
+        assert period_asfreq(1, get_freq('D'),
+                             get_freq('U'), False) == 86400000000
+        assert period_asfreq(1, get_freq('D'),
+                             get_freq('N'), False) == 86400000000000
+
+        assert period_asfreq(1, get_freq('H'), get_freq('T'), False) == 60
+        assert period_asfreq(1, get_freq('H'), get_freq('S'), False) == 3600
+        assert period_asfreq(1, get_freq('H'),
+                             get_freq('L'), False) == 3600000
+        assert period_asfreq(1, get_freq('H'),
+                             get_freq('U'), False) == 3600000000
+        assert period_asfreq(1, get_freq('H'),
+                             get_freq('N'), False) == 3600000000000
+
+        assert period_asfreq(1, get_freq('T'), get_freq('S'), False) == 60
+        assert period_asfreq(1, get_freq('T'), get_freq('L'), False) == 60000
+        assert period_asfreq(1, get_freq('T'),
+                             get_freq('U'), False) == 60000000
+        assert period_asfreq(1, get_freq('T'),
+                             get_freq('N'), False) == 60000000000
+
+        assert period_asfreq(1, get_freq('S'), get_freq('L'), False) == 1000
+        assert period_asfreq(1, get_freq('S'),
+                             get_freq('U'), False) == 1000000
+        assert period_asfreq(1, get_freq('S'),
+                             get_freq('N'), False) == 1000000000
+
+        assert period_asfreq(1, get_freq('L'), get_freq('U'), False) == 1000
+        assert period_asfreq(1, get_freq('L'),
+                             get_freq('N'), False) == 1000000
+
+        assert period_asfreq(1, get_freq('U'), get_freq('N'), False) == 1000
+
+    def test_period_ordinal_start_values(self):
+        # information for 1.1.1970
+        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('A')) == 0
+        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')) == 0
+        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')) == 1
+        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')) == 0
+        assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')) == 0
+
+    def test_period_ordinal_week(self):
+        assert period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0, get_freq('W')) == 1
+        assert period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0, get_freq('W')) == 2
+        assert period_ordinal(2013, 10, 6, 0,
+                              0, 0, 0, 0, get_freq('W')) == 2284
+        assert period_ordinal(2013, 10, 7, 0,
+                              0, 0, 0, 0, get_freq('W')) == 2285
+
+    def test_period_ordinal_business_day(self):
+        # Thursday
+        assert period_ordinal(2013, 10, 3, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11415
+        # Friday
+        assert period_ordinal(2013, 10, 4, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11416
+        # Saturday
+        assert period_ordinal(2013, 10, 5, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11417
+        # Sunday
+        assert period_ordinal(2013, 10, 6, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11417
+        # Monday
+        assert period_ordinal(2013, 10, 7, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11417
+        # Tuesday
+        assert period_ordinal(2013, 10, 8, 0,
+                              0, 0, 0, 0, get_freq('B')) == 11418
diff --git a/pandas/tests/tslibs/test_timezones.py b/pandas/tests/tslibs/test_timezones.py
new file mode 100644
index 0000000000000..955de448861e2
--- /dev/null
+++ b/pandas/tests/tslibs/test_timezones.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+from datetime import datetime
+
+import pytest
+import pytz
+import dateutil.tz
+
+from pandas._libs.tslibs import timezones
+from pandas import Timestamp
+
+
+class TestTimeZoneCacheKey(object):
+
+    @pytest.mark.parametrize('tz_name', list(pytz.common_timezones))
+    def test_cache_keys_are_distinct_for_pytz_vs_dateutil(self, tz_name):
+        if tz_name == 'UTC':
+            # skip utc as it's a special case in dateutil
+            return
+        tz_p = timezones.maybe_get_tz(tz_name)
+        tz_d = timezones.maybe_get_tz('dateutil/' + tz_name)
+        if tz_d is None:
+            # skip timezones that dateutil doesn't know about.
+            return
+        assert (timezones._p_tz_cache_key(tz_p) !=
+                timezones._p_tz_cache_key(tz_d))
+
+
+def test_tzlocal():
+    # GH#13583
+    ts = Timestamp('2011-01-01', tz=dateutil.tz.tzlocal())
+    assert ts.tz == dateutil.tz.tzlocal()
+    assert "tz='tzlocal()')" in repr(ts)
+
+    tz = timezones.maybe_get_tz('tzlocal()')
+    assert tz == dateutil.tz.tzlocal()
+
+    # get offset using normal datetime for test
+    offset = dateutil.tz.tzlocal().utcoffset(datetime(2011, 1, 1))
+    offset = offset.total_seconds() * 1000000000
+    assert ts.value + offset == Timestamp('2011-01-01').value
diff --git a/pandas/tests/tslibs/test_tslib.py b/pandas/tests/tslibs/test_tslib.py
new file mode 100644
index 0000000000000..b8b484991e7b5
--- /dev/null
+++ b/pandas/tests/tslibs/test_tslib.py
@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+import calendar
+from datetime import datetime, date
+
+import numpy as np
+import pytest
+
+from pandas import compat
+from pandas._libs import tslib
+from pandas.compat.numpy import np_array_datetime64_compat
+import pandas.util.testing as tm
+
+
+def test_monthrange():
+    for y in range(2000, 2013):
+        for m in range(1, 13):
+            assert tslib.monthrange(y, m) == calendar.monthrange(y, m)
+
+
+def test_normalize_datetime():
+    actual = tslib.normalize_date(datetime(2007, 10, 1, 1, 12, 5, 10))
+    assert actual == datetime(2007, 10, 1)
+
+
+def test_normalize_date():
+    value = date(2012, 9, 7)
+
+    result = tslib.normalize_date(value)
+    assert (result == datetime(2012, 9, 7))
+
+    value = datetime(2012, 9, 7, 12)
+
+    result = tslib.normalize_date(value)
+    assert (result == datetime(2012, 9, 7))
+
+
+class TestParseISO8601(object):
+    def test_parsers_iso8601(self):
+        # GH#12060
+        # test only the iso parser - flexibility to different
+        # separators and leadings 0s
+        # Timestamp construction falls back to dateutil
+        cases = {'2011-01-02': datetime(2011, 1, 2),
+                 '2011-1-2': datetime(2011, 1, 2),
+                 '2011-01': datetime(2011, 1, 1),
+                 '2011-1': datetime(2011, 1, 1),
+                 '2011 01 02': datetime(2011, 1, 2),
+                 '2011.01.02': datetime(2011, 1, 2),
+                 '2011/01/02': datetime(2011, 1, 2),
+                 '2011\\01\\02': datetime(2011, 1, 2),
+                 '2013-01-01 05:30:00': datetime(2013, 1, 1, 5, 30),
+                 '2013-1-1 5:30:00': datetime(2013, 1, 1, 5, 30)}
+        for date_str, exp in compat.iteritems(cases):
+            actual = tslib._test_parse_iso8601(date_str)
+            assert actual == exp
+
+    @pytest.mark.parametrize('date_str', ['2011-01/02', '2011^11^11',
+                                          '201401', '201111', '200101',
+                                          # mixed separated and unseparated
+                                          '2005-0101', '200501-01',
+                                          '20010101 12:3456',
+                                          '20010101 1234:56',
+                                          # HHMMSS must have two digits in
+                                          # each component if unseparated
+                                          '20010101 1', '20010101 123',
+                                          '20010101 12345', '20010101 12345Z',
+                                          # wrong separator for HHMMSS
+                                          '2001-01-01 12-34-56'])
+    def test_parsers_iso8601_invalid(self, date_str):
+        # separators must all match - YYYYMM not valid
+        with pytest.raises(ValueError):
+            tslib._test_parse_iso8601(date_str)
+            # If no ValueError raised, let me know which case failed.
+            raise Exception(date_str)
+
+
+class TestArrayToDatetime(object):
+    def test_parsing_valid_dates(self):
+        arr = np.array(['01-01-2013', '01-02-2013'], dtype=object)
+        result = tslib.array_to_datetime(arr)
+        expected = ['2013-01-01T00:00:00.000000000-0000',
+                    '2013-01-02T00:00:00.000000000-0000']
+        tm.assert_numpy_array_equal(result,
+                                    np_array_datetime64_compat(expected,
+                                                               dtype='M8[ns]'))
+
+        arr = np.array(['Mon Sep 16 2013', 'Tue Sep 17 2013'], dtype=object)
+        result = tslib.array_to_datetime(arr)
+        expected = ['2013-09-16T00:00:00.000000000-0000',
+                    '2013-09-17T00:00:00.000000000-0000']
+        tm.assert_numpy_array_equal(result,
+                                    np_array_datetime64_compat(expected,
+                                                               dtype='M8[ns]'))
+
+    @pytest.mark.parametrize('dt_string', [
+        '01-01-2013 08:00:00+08:00',
+        '2013-01-01T08:00:00.000000000+0800',
+        '2012-12-31T16:00:00.000000000-0800',
+        '12-31-2012 23:00:00-01:00'])
+    def test_parsing_timezone_offsets(self, dt_string):
+        # All of these datetime strings with offsets are equivalent
+        # to the same datetime after the timezone offset is added
+        arr = np.array(['01-01-2013 00:00:00'], dtype=object)
+        expected = tslib.array_to_datetime(arr)
+
+        arr = np.array([dt_string], dtype=object)
+        result = tslib.array_to_datetime(arr)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_number_looking_strings_not_into_datetime(self):
+        # #4601
+        # These strings don't look like datetimes so they shouldn't be
+        # attempted to be converted
+        arr = np.array(['-352.737091', '183.575577'], dtype=object)
+        result = tslib.array_to_datetime(arr, errors='ignore')
+        tm.assert_numpy_array_equal(result, arr)
+
+        arr = np.array(['1', '2', '3', '4', '5'], dtype=object)
+        result = tslib.array_to_datetime(arr, errors='ignore')
+        tm.assert_numpy_array_equal(result, arr)
+
+    @pytest.mark.parametrize('invalid_date', [date(1000, 1, 1),
+                                              datetime(1000, 1, 1),
+                                              '1000-01-01',
+                                              'Jan 1, 1000',
+                                              np.datetime64('1000-01-01')])
+    def test_coerce_outside_ns_bounds(self, invalid_date):
+        arr = np.array([invalid_date], dtype='object')
+        with pytest.raises(ValueError):
+            tslib.array_to_datetime(arr, errors='raise')
+
+        result = tslib.array_to_datetime(arr, errors='coerce')
+        expected = np.array([tslib.iNaT], dtype='M8[ns]')
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_coerce_outside_ns_bounds_one_valid(self):
+        arr = np.array(['1/1/1000', '1/1/2000'], dtype=object)
+        result = tslib.array_to_datetime(arr, errors='coerce')
+        expected = [tslib.iNaT,
+                    '2000-01-01T00:00:00.000000000-0000'],
+        tm.assert_numpy_array_equal(result,
+                                    np_array_datetime64_compat(expected,
+                                                               dtype='M8[ns]'))
+
+    def test_coerce_of_invalid_datetimes(self):
+        arr = np.array(['01-01-2013', 'not_a_date', '1'], dtype=object)
+
+        # Without coercing, the presence of any invalid dates prevents
+        # any values from being converted
+        result = tslib.array_to_datetime(arr, errors='ignore')
+        tm.assert_numpy_array_equal(result, arr)
+
+        # With coercing, the invalid dates becomes iNaT
+        result = tslib.array_to_datetime(arr, errors='coerce')
+        expected = ['2013-01-01T00:00:00.000000000-0000',
+                    tslib.iNaT,
+                    tslib.iNaT]
+
+        tm.assert_numpy_array_equal(result,
+                                    np_array_datetime64_compat(expected,
+                                                               dtype='M8[ns]'))
+
+    def test_to_datetime_barely_out_of_bounds(self):
+        # GH#19529
+        # GH#19382 close enough to bounds that dropping nanos would result
+        # in an in-bounds datetime
+        arr = np.array(['2262-04-11 23:47:16.854775808'], dtype=object)
+        with pytest.raises(tslib.OutOfBoundsDatetime):
+            tslib.array_to_datetime(arr)