content: # -*- coding: utf-8 -*-
  
  """
  Tests that quoting specifications are properly handled
  during parsing for all of the parsers defined in parsers.py
  """
  
  import csv
  import pandas.util.testing as tm
  
  from pandas import DataFrame
  from pandas.compat import PY3, StringIO, u
  
  
  class QuotingTests(object):
  
      def test_bad_quote_char(self):
          data = '1,2,3'
  
          # Python 2.x: "...must be an 1-character..."
          # Python 3.x: "...must be a 1-character..."
          msg = '"quotechar" must be a(n)? 1-character string'
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quotechar='foo')
  
          msg = 'quotechar must be set if quoting enabled'
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quotechar=None,
                                quoting=csv.QUOTE_MINIMAL)
  
          msg = '"quotechar" must be string, not int'
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quotechar=2)
  
      def test_bad_quoting(self):
          data = '1,2,3'
  
          msg = '"quoting" must be an integer'
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quoting='foo')
  
          # quoting must in the range [0, 3]
          msg = 'bad "quoting" value'
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quoting=5)
  
      def test_quote_char_basic(self):
          data = 'a,b,c\n1,2,"cat"'
          expected = DataFrame([[1, 2, 'cat']],
                               columns=['a', 'b', 'c'])
          result = self.read_csv(StringIO(data), quotechar='"')
          tm.assert_frame_equal(result, expected)
  
      def test_quote_char_various(self):
          data = 'a,b,c\n1,2,"cat"'
          expected = DataFrame([[1, 2, 'cat']],
                               columns=['a', 'b', 'c'])
          quote_chars = ['~', '*', '%', '$', '@', 'P']
  
          for quote_char in quote_chars:
              new_data = data.replace('"', quote_char)
              result = self.read_csv(StringIO(new_data), quotechar=quote_char)
              tm.assert_frame_equal(result, expected)
  
      def test_null_quote_char(self):
          data = 'a,b,c\n1,2,3'
  
          # sanity checks
          msg = 'quotechar must be set if quoting enabled'
  
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quotechar=None,
                                quoting=csv.QUOTE_MINIMAL)
  
          tm.assertRaisesRegexp(TypeError, msg, self.read_csv,
                                StringIO(data), quotechar='',
                                quoting=csv.QUOTE_MINIMAL)
  
          # no errors should be raised if quoting is None
          expected = DataFrame([[1, 2, 3]],
                               columns=['a', 'b', 'c'])
  
          result = self.read_csv(StringIO(data), quotechar=None,
                                 quoting=csv.QUOTE_NONE)
          tm.assert_frame_equal(result, expected)
  
          result = self.read_csv(StringIO(data), quotechar='',
                                 quoting=csv.QUOTE_NONE)
          tm.assert_frame_equal(result, expected)
  
      def test_quoting_various(self):
          data = '1,2,"foo"'
          cols = ['a', 'b', 'c']
  
          # QUOTE_MINIMAL and QUOTE_ALL apply only to
          # the CSV writer, so they should have no
          # special effect for the CSV reader
          expected = DataFrame([[1, 2, 'foo']], columns=cols)
  
          # test default (afterwards, arguments are all explicit)
          result = self.read_csv(StringIO(data), names=cols)
          tm.assert_frame_equal(result, expected)
  
          result = self.read_csv(StringIO(data), quotechar='"',
                                 quoting=csv.QUOTE_MINIMAL, names=cols)
          tm.assert_frame_equal(result, expected)
  
          result = self.read_csv(StringIO(data), quotechar='"',
                                 quoting=csv.QUOTE_ALL, names=cols)
          tm.assert_frame_equal(result, expected)
  
          # QUOTE_NONE tells the reader to do no special handling
          # of quote characters and leave them alone
          expected = DataFrame([[1, 2, '"foo"']], columns=cols)
          result = self.read_csv(StringIO(data), quotechar='"',
                                 quoting=csv.QUOTE_NONE, names=cols)
          tm.assert_frame_equal(result, expected)
  
          # QUOTE_NONNUMERIC tells the reader to cast
          # all non-quoted fields to float
          expected = DataFrame([[1.0, 2.0, 'foo']], columns=cols)
          result = self.read_csv(StringIO(data), quotechar='"',
                                 quoting=csv.QUOTE_NONNUMERIC,
                                 names=cols)
          tm.assert_frame_equal(result, expected)
  
      def test_double_quote(self):
          data = 'a,b\n3,"4 "" 5"'
  
          expected = DataFrame([[3, '4 " 5']],
                               columns=['a', 'b'])
          result = self.read_csv(StringIO(data), quotechar='"',
                                 doublequote=True)
          tm.assert_frame_equal(result, expected)
  
          expected = DataFrame([[3, '4 " 5"']],
                               columns=['a', 'b'])
          result = self.read_csv(StringIO(data), quotechar='"',
                                 doublequote=False)
          tm.assert_frame_equal(result, expected)
  
      def test_quotechar_unicode(self):
          # See gh-14477
          data = 'a\n1'
          expected = DataFrame({'a': [1]})
  
          result = self.read_csv(StringIO(data), quotechar=u('"'))
          tm.assert_frame_equal(result, expected)
  
          # Compared to Python 3.x, Python 2.x does not handle unicode well.
          if PY3:
              result = self.read_csv(StringIO(data), quotechar=u('\u0394'))
              tm.assert_frame_equal(result, expected)
  