content: # -*- coding: utf-8 -*-
  """
  Tests for Timestamp parsing, aimed at pandas/_libs/tslibs/parsing.pyx
  """
  from datetime import datetime
  
  from dateutil.parser import parse
  import numpy as np
  import pytest
  
  from pandas._libs.tslibs import parsing
  from pandas._libs.tslibs.parsing import parse_time_string
  import pandas.util._test_decorators as td
  
  from pandas.util import 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")
  
      assert date == date_lower
      assert reso == reso_lower
      assert parsed == parsed_lower
  
  
  @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)
  
      assert date_dash == date
      assert parsed_dash == parsed
      assert reso_dash == reso
  
  
  @pytest.mark.parametrize("dashed", [
      "-2Q1992", "2-Q1992", "4-4Q1992"
  ])
  def test_parse_time_quarter_with_dash_error(dashed):
      msg = ("Unknown datetime string format, "
             "unable to parse: {dashed}".format(dashed=dashed))
  
      with pytest.raises(parsing.DateParseError, match=msg):
          parse_time_string(dashed)
  
  
  @pytest.mark.parametrize("date_string,expected", [
      ("123.1234", False),
      ("-50000", False),
      ("999", False),
      ("m", False),
      ("T", False),
  
      ("Mon Sep 16, 2013", True),
      ("2012-01-01", True),
      ("01/01/2012", True),
      ("01012012", True),
      ("0101", True),
      ("1-1", True)
  ])
  def test_does_not_convert_mixed_integer(date_string, expected):
      assert parsing._does_string_look_like_datetime(date_string) is expected
  
  
  @pytest.mark.parametrize("date_str,kwargs,msg", [
      ("2013Q5", dict(),
       ("Incorrect quarterly string is given, "
        "quarter must be between 1 and 4: 2013Q5")),
  
      # see gh-5418
      ("2013Q1", dict(freq="INVLD-L-DEC-SAT"),
       ("Unable to retrieve month information "
        "from given freq: INVLD-L-DEC-SAT"))
  ])
  def test_parsers_quarterly_with_freq_error(date_str, kwargs, msg):
      with pytest.raises(parsing.DateParseError, match=msg):
          parsing.parse_time_string(date_str, **kwargs)
  
  
  @pytest.mark.parametrize("date_str,freq,expected", [
      ("2013Q2", None, datetime(2013, 4, 1)),
      ("2013Q2", "A-APR", datetime(2012, 8, 1)),
      ("2013-Q2", "A-DEC", datetime(2013, 4, 1))
  ])
  def test_parsers_quarterly_with_freq(date_str, freq, expected):
      result, _, _ = parsing.parse_time_string(date_str, freq=freq)
      assert result == expected
  
  
  @pytest.mark.parametrize("date_str", [
      "2Q 2005", "2Q-200A", "2Q-200",
      "22Q2005", "2Q200.", "6Q-20"
  ])
  def test_parsers_quarter_invalid(date_str):
      if date_str == "6Q-20":
          msg = ("Incorrect quarterly string is given, quarter "
                 "must be between 1 and 4: {date_str}".format(date_str=date_str))
      else:
          msg = ("Unknown datetime string format, unable "
                 "to parse: {date_str}".format(date_str=date_str))
  
      with pytest.raises(ValueError, match=msg):
          parsing.parse_time_string(date_str)
  
  
  @pytest.mark.parametrize("date_str,expected", [
      ("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")
      assert result == expected
  
  
  @td.skip_if_not_us_locale
  @pytest.mark.parametrize("string,fmt", [
      ("20111230", "%Y%m%d"),
      ("2011-12-30", "%Y-%m-%d"),
      ("30-12-2011", "%d-%m-%Y"),
      ("2011-12-30 00:00:00", "%Y-%m-%d %H:%M:%S"),
      ("2011-12-30T00:00:00", "%Y-%m-%dT%H:%M:%S"),
      ("2011-12-30 00:00:00.000000", "%Y-%m-%d %H:%M:%S.%f")
  ])
  def test_guess_datetime_format_with_parseable_formats(string, fmt):
      result = parsing._guess_datetime_format(string)
      assert result == fmt
  
  
  @pytest.mark.parametrize("dayfirst,expected", [
      (True, "%d/%m/%Y"),
      (False, "%m/%d/%Y")
  ])
  def test_guess_datetime_format_with_dayfirst(dayfirst, expected):
      ambiguous_string = "01/01/2011"
      result = parsing._guess_datetime_format(ambiguous_string,
                                              dayfirst=dayfirst)
      assert result == expected
  
  
  @td.skip_if_has_locale
  @pytest.mark.parametrize("string,fmt", [
      ("30/Dec/2011", "%d/%b/%Y"),
      ("30/December/2011", "%d/%B/%Y"),
      ("30/Dec/2011 00:00:00", "%d/%b/%Y %H:%M:%S")
  ])
  def test_guess_datetime_format_with_locale_specific_formats(string, fmt):
      result = parsing._guess_datetime_format(string)
      assert result == fmt
  
  
  @pytest.mark.parametrize("invalid_dt", [
      "2013", "01/2013", "12:00:00", "1/1/1/1",
      "this_is_not_a_datetime", "51a", 9,
      datetime(2011, 1, 1)
  ])
  def test_guess_datetime_format_invalid_inputs(invalid_dt):
      # A datetime string must include a year, month and a day for it to be
      # guessable, in addition to being a string that looks like a datetime.
      assert parsing._guess_datetime_format(invalid_dt) is None
  
  
  @pytest.mark.parametrize("string,fmt", [
      ("2011-1-1", "%Y-%m-%d"),
      ("1/1/2011", "%m/%d/%Y"),
      ("30-1-2011", "%d-%m-%Y"),
      ("2011-1-1 0:0:0", "%Y-%m-%d %H:%M:%S"),
      ("2011-1-3T00:00:0", "%Y-%m-%dT%H:%M:%S"),
      ("2011-1-1 00:00:00", "%Y-%m-%d %H:%M:%S")
  ])
  def test_guess_datetime_format_no_padding(string, fmt):
      # see gh-11142
      result = parsing._guess_datetime_format(string)
      assert result == fmt
  
  
  def test_try_parse_dates():
      arr = np.array(["5/1/2000", "6/1/2000", "7/1/2000"], dtype=object)
      result = parsing.try_parse_dates(arr, dayfirst=True)
  
      expected = np.array([parse(d, dayfirst=True) for d in arr])
      tm.assert_numpy_array_equal(result, expected)
  