Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_quoting.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests that quoting specifications are properly handled
+during parsing for all of the parsers defined in parsers.py
+"""
+
+import csv
+
+import pytest
+
+from pandas.compat import PY2, StringIO, u
+from pandas.errors import ParserError
+
+from pandas import DataFrame
+import pandas.util.testing as tm
+
+
+@pytest.mark.parametrize("kwargs,msg", [
+    (dict(quotechar="foo"), '"quotechar" must be a(n)? 1-character string'),
+    (dict(quotechar=None, quoting=csv.QUOTE_MINIMAL),
+     "quotechar must be set if quoting enabled"),
+    (dict(quotechar=2), '"quotechar" must be string, not int')
+])
+def test_bad_quote_char(all_parsers, kwargs, msg):
+    data = "1,2,3"
+    parser = all_parsers
+
+    with pytest.raises(TypeError, match=msg):
+        parser.read_csv(StringIO(data), **kwargs)
+
+
+@pytest.mark.parametrize("quoting,msg", [
+    ("foo", '"quoting" must be an integer'),
+    (5, 'bad "quoting" value'),  # quoting must be in the range [0, 3]
+])
+def test_bad_quoting(all_parsers, quoting, msg):
+    data = "1,2,3"
+    parser = all_parsers
+
+    with pytest.raises(TypeError, match=msg):
+        parser.read_csv(StringIO(data), quoting=quoting)
+
+
+def test_quote_char_basic(all_parsers):
+    parser = all_parsers
+    data = 'a,b,c\n1,2,"cat"'
+    expected = DataFrame([[1, 2, "cat"]],
+                         columns=["a", "b", "c"])
+
+    result = parser.read_csv(StringIO(data), quotechar='"')
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("quote_char", ["~", "*", "%", "$", "@", "P"])
+def test_quote_char_various(all_parsers, quote_char):
+    parser = all_parsers
+    expected = DataFrame([[1, 2, "cat"]],
+                         columns=["a", "b", "c"])
+
+    data = 'a,b,c\n1,2,"cat"'
+    new_data = data.replace('"', quote_char)
+
+    result = parser.read_csv(StringIO(new_data), quotechar=quote_char)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("quoting", [csv.QUOTE_MINIMAL, csv.QUOTE_NONE])
+@pytest.mark.parametrize("quote_char", ["", None])
+def test_null_quote_char(all_parsers, quoting, quote_char):
+    kwargs = dict(quotechar=quote_char, quoting=quoting)
+    data = "a,b,c\n1,2,3"
+    parser = all_parsers
+
+    if quoting != csv.QUOTE_NONE:
+        # Sanity checking.
+        msg = "quotechar must be set if quoting enabled"
+
+        with pytest.raises(TypeError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+    else:
+        expected = DataFrame([[1, 2, 3]], columns=["a", "b", "c"])
+        result = parser.read_csv(StringIO(data), **kwargs)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kwargs,exp_data", [
+    (dict(), [[1, 2, "foo"]]),  # Test default.
+
+    # QUOTE_MINIMAL only applies to CSV writing, so no effect on reading.
+    (dict(quotechar='"', quoting=csv.QUOTE_MINIMAL), [[1, 2, "foo"]]),
+
+    # QUOTE_MINIMAL only applies to CSV writing, so no effect on reading.
+    (dict(quotechar='"', quoting=csv.QUOTE_ALL), [[1, 2, "foo"]]),
+
+    # QUOTE_NONE tells the reader to do no special handling
+    # of quote characters and leave them alone.
+    (dict(quotechar='"', quoting=csv.QUOTE_NONE), [[1, 2, '"foo"']]),
+
+    # QUOTE_NONNUMERIC tells the reader to cast
+    # all non-quoted fields to float
+    (dict(quotechar='"', quoting=csv.QUOTE_NONNUMERIC), [[1.0, 2.0, "foo"]])
+])
+def test_quoting_various(all_parsers, kwargs, exp_data):
+    data = '1,2,"foo"'
+    parser = all_parsers
+    columns = ["a", "b", "c"]
+
+    result = parser.read_csv(StringIO(data), names=columns, **kwargs)
+    expected = DataFrame(exp_data, columns=columns)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("doublequote,exp_data", [
+    (True, [[3, '4 " 5']]),
+    (False, [[3, '4 " 5"']]),
+])
+def test_double_quote(all_parsers, doublequote, exp_data):
+    parser = all_parsers
+    data = 'a,b\n3,"4 "" 5"'
+
+    result = parser.read_csv(StringIO(data), quotechar='"',
+                             doublequote=doublequote)
+    expected = DataFrame(exp_data, columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("quotechar", [
+    u('"'),
+    pytest.param(u('\u0001'), marks=pytest.mark.skipif(
+        PY2, reason="Python 2.x does not handle unicode well."))])
+def test_quotechar_unicode(all_parsers, quotechar):
+    # see gh-14477
+    data = "a\n1"
+    parser = all_parsers
+    expected = DataFrame({"a": [1]})
+
+    result = parser.read_csv(StringIO(data), quotechar=quotechar)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("balanced", [True, False])
+def test_unbalanced_quoting(all_parsers, balanced):
+    # see gh-22789.
+    parser = all_parsers
+    data = "a,b,c\n1,2,\"3"
+
+    if balanced:
+        # Re-balance the quoting and read in without errors.
+        expected = DataFrame([[1, 2, 3]], columns=["a", "b", "c"])
+        result = parser.read_csv(StringIO(data + '"'))
+        tm.assert_frame_equal(result, expected)
+    else:
+        msg = ("EOF inside string starting at row 1" if parser.engine == "c"
+               else "unexpected end of data")
+
+        with pytest.raises(ParserError, match=msg):
+            parser.read_csv(StringIO(data))

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_read_fwf.py

@@ -0,0 +1,580 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests the 'read_fwf' function in parsers.py. This
+test suite is independent of the others because the
+engine is set to 'python-fwf' internally.
+"""
+
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas.compat as compat
+from pandas.compat import BytesIO, StringIO
+
+import pandas as pd
+from pandas import DataFrame, DatetimeIndex
+import pandas.util.testing as tm
+
+from pandas.io.parsers import EmptyDataError, read_csv, read_fwf
+
+
+def test_basic():
+    data = """\
+A         B            C            D
+201158    360.242940   149.910199   11950.7
+201159    444.953632   166.985655   11788.4
+201160    364.136849   183.628767   11806.2
+201161    413.836124   184.375703   11916.8
+201162    502.953953   173.237159   12468.3
+"""
+    result = read_fwf(StringIO(data))
+    expected = DataFrame([[201158, 360.242940, 149.910199, 11950.7],
+                          [201159, 444.953632, 166.985655, 11788.4],
+                          [201160, 364.136849, 183.628767, 11806.2],
+                          [201161, 413.836124, 184.375703, 11916.8],
+                          [201162, 502.953953, 173.237159, 12468.3]],
+                         columns=["A", "B", "C", "D"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_colspecs():
+    data = """\
+A   B     C            D            E
+201158    360.242940   149.910199   11950.7
+201159    444.953632   166.985655   11788.4
+201160    364.136849   183.628767   11806.2
+201161    413.836124   184.375703   11916.8
+201162    502.953953   173.237159   12468.3
+"""
+    colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)]
+    result = read_fwf(StringIO(data), colspecs=colspecs)
+
+    expected = DataFrame([[2011, 58, 360.242940, 149.910199, 11950.7],
+                          [2011, 59, 444.953632, 166.985655, 11788.4],
+                          [2011, 60, 364.136849, 183.628767, 11806.2],
+                          [2011, 61, 413.836124, 184.375703, 11916.8],
+                          [2011, 62, 502.953953, 173.237159, 12468.3]],
+                         columns=["A", "B", "C", "D", "E"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_widths():
+    data = """\
+A    B    C            D            E
+2011 58   360.242940   149.910199   11950.7
+2011 59   444.953632   166.985655   11788.4
+2011 60   364.136849   183.628767   11806.2
+2011 61   413.836124   184.375703   11916.8
+2011 62   502.953953   173.237159   12468.3
+"""
+    result = read_fwf(StringIO(data), widths=[5, 5, 13, 13, 7])
+
+    expected = DataFrame([[2011, 58, 360.242940, 149.910199, 11950.7],
+                          [2011, 59, 444.953632, 166.985655, 11788.4],
+                          [2011, 60, 364.136849, 183.628767, 11806.2],
+                          [2011, 61, 413.836124, 184.375703, 11916.8],
+                          [2011, 62, 502.953953, 173.237159, 12468.3]],
+                         columns=["A", "B", "C", "D", "E"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_non_space_filler():
+    # From Thomas Kluyver:
+    #
+    # Apparently, some non-space filler characters can be seen, this is
+    # supported by specifying the 'delimiter' character:
+    #
+    # http://publib.boulder.ibm.com/infocenter/dmndhelp/v6r1mx/index.jsp?topic=/com.ibm.wbit.612.help.config.doc/topics/rfixwidth.html
+    data = """\
+A~~~~B~~~~C~~~~~~~~~~~~D~~~~~~~~~~~~E
+201158~~~~360.242940~~~149.910199~~~11950.7
+201159~~~~444.953632~~~166.985655~~~11788.4
+201160~~~~364.136849~~~183.628767~~~11806.2
+201161~~~~413.836124~~~184.375703~~~11916.8
+201162~~~~502.953953~~~173.237159~~~12468.3
+"""
+    colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)]
+    result = read_fwf(StringIO(data), colspecs=colspecs, delimiter="~")
+
+    expected = DataFrame([[2011, 58, 360.242940, 149.910199, 11950.7],
+                          [2011, 59, 444.953632, 166.985655, 11788.4],
+                          [2011, 60, 364.136849, 183.628767, 11806.2],
+                          [2011, 61, 413.836124, 184.375703, 11916.8],
+                          [2011, 62, 502.953953, 173.237159, 12468.3]],
+                         columns=["A", "B", "C", "D", "E"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_over_specified():
+    data = """\
+A   B     C            D            E
+201158    360.242940   149.910199   11950.7
+201159    444.953632   166.985655   11788.4
+201160    364.136849   183.628767   11806.2
+201161    413.836124   184.375703   11916.8
+201162    502.953953   173.237159   12468.3
+"""
+    colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)]
+
+    with pytest.raises(ValueError, match="must specify only one of"):
+        read_fwf(StringIO(data), colspecs=colspecs, widths=[6, 10, 10, 7])
+
+
+def test_under_specified():
+    data = """\
+A   B     C            D            E
+201158    360.242940   149.910199   11950.7
+201159    444.953632   166.985655   11788.4
+201160    364.136849   183.628767   11806.2
+201161    413.836124   184.375703   11916.8
+201162    502.953953   173.237159   12468.3
+"""
+    with pytest.raises(ValueError, match="Must specify either"):
+        read_fwf(StringIO(data), colspecs=None, widths=None)
+
+
+def test_read_csv_compat():
+    csv_data = """\
+A,B,C,D,E
+2011,58,360.242940,149.910199,11950.7
+2011,59,444.953632,166.985655,11788.4
+2011,60,364.136849,183.628767,11806.2
+2011,61,413.836124,184.375703,11916.8
+2011,62,502.953953,173.237159,12468.3
+"""
+    expected = read_csv(StringIO(csv_data), engine="python")
+
+    fwf_data = """\
+A   B     C            D            E
+201158    360.242940   149.910199   11950.7
+201159    444.953632   166.985655   11788.4
+201160    364.136849   183.628767   11806.2
+201161    413.836124   184.375703   11916.8
+201162    502.953953   173.237159   12468.3
+"""
+    colspecs = [(0, 4), (4, 8), (8, 20), (21, 33), (34, 43)]
+    result = read_fwf(StringIO(fwf_data), colspecs=colspecs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_bytes_io_input():
+    if not compat.PY3:
+        pytest.skip("Bytes-related test - only needs to work on Python 3")
+
+    result = read_fwf(BytesIO("שלום\nשלום".encode('utf8')),
+                      widths=[2, 2], encoding="utf8")
+    expected = DataFrame([["של", "ום"]], columns=["של", "ום"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_fwf_colspecs_is_list_or_tuple():
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+
+    msg = "column specifications must be a list or tuple.+"
+
+    with pytest.raises(TypeError, match=msg):
+        read_fwf(StringIO(data), colspecs={"a": 1}, delimiter=",")
+
+
+def test_fwf_colspecs_is_list_or_tuple_of_two_element_tuples():
+    data = """index,A,B,C,D
+foo,2,3,4,5
+bar,7,8,9,10
+baz,12,13,14,15
+qux,12,13,14,15
+foo2,12,13,14,15
+bar2,12,13,14,15
+"""
+
+    msg = "Each column specification must be.+"
+
+    with pytest.raises(TypeError, match=msg):
+        read_fwf(StringIO(data), [("a", 1)])
+
+
+@pytest.mark.parametrize("colspecs,exp_data", [
+    ([(0, 3), (3, None)], [[123, 456], [456, 789]]),
+    ([(None, 3), (3, 6)], [[123, 456], [456, 789]]),
+    ([(0, None), (3, None)], [[123456, 456], [456789, 789]]),
+    ([(None, None), (3, 6)], [[123456, 456], [456789, 789]]),
+])
+def test_fwf_colspecs_none(colspecs, exp_data):
+    # see gh-7079
+    data = """\
+123456
+456789
+"""
+    expected = DataFrame(exp_data)
+
+    result = read_fwf(StringIO(data), colspecs=colspecs, header=None)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("infer_nrows,exp_data", [
+    # infer_nrows --> colspec == [(2, 3), (5, 6)]
+    (1, [[1, 2], [3, 8]]),
+
+    # infer_nrows > number of rows
+    (10, [[1, 2], [123, 98]]),
+])
+def test_fwf_colspecs_infer_nrows(infer_nrows, exp_data):
+    # see gh-15138
+    data = """\
+  1  2
+123 98
+"""
+    expected = DataFrame(exp_data)
+
+    result = read_fwf(StringIO(data), infer_nrows=infer_nrows, header=None)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_fwf_regression():
+    # see gh-3594
+    #
+    # Turns out "T060" is parsable as a datetime slice!
+    tz_list = [1, 10, 20, 30, 60, 80, 100]
+    widths = [16] + [8] * len(tz_list)
+    names = ["SST"] + ["T%03d" % z for z in tz_list[1:]]
+
+    data = """  2009164202000   9.5403  9.4105  8.6571  7.8372  6.0612  5.8843  5.5192
+2009164203000   9.5435  9.2010  8.6167  7.8176  6.0804  5.8728  5.4869
+2009164204000   9.5873  9.1326  8.4694  7.5889  6.0422  5.8526  5.4657
+2009164205000   9.5810  9.0896  8.4009  7.4652  6.0322  5.8189  5.4379
+2009164210000   9.6034  9.0897  8.3822  7.4905  6.0908  5.7904  5.4039
+"""
+
+    result = read_fwf(StringIO(data), index_col=0, header=None, names=names,
+                      widths=widths, parse_dates=True,
+                      date_parser=lambda s: datetime.strptime(s, "%Y%j%H%M%S"))
+    expected = DataFrame([
+        [9.5403, 9.4105, 8.6571, 7.8372, 6.0612, 5.8843, 5.5192],
+        [9.5435, 9.2010, 8.6167, 7.8176, 6.0804, 5.8728, 5.4869],
+        [9.5873, 9.1326, 8.4694, 7.5889, 6.0422, 5.8526, 5.4657],
+        [9.5810, 9.0896, 8.4009, 7.4652, 6.0322, 5.8189, 5.4379],
+        [9.6034, 9.0897, 8.3822, 7.4905, 6.0908, 5.7904, 5.4039],
+    ], index=DatetimeIndex(["2009-06-13 20:20:00", "2009-06-13 20:30:00",
+                            "2009-06-13 20:40:00", "2009-06-13 20:50:00",
+                            "2009-06-13 21:00:00"]),
+        columns=["SST", "T010", "T020", "T030", "T060", "T080", "T100"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_fwf_for_uint8():
+    data = """1421302965.213420    PRI=3 PGN=0xef00      DST=0x17 SRC=0x28    04 154 00 00 00 00 00 127
+1421302964.226776    PRI=6 PGN=0xf002               SRC=0x47    243 00 00 255 247 00 00 71"""  # noqa
+    df = read_fwf(StringIO(data),
+                  colspecs=[(0, 17), (25, 26), (33, 37),
+                            (49, 51), (58, 62), (63, 1000)],
+                  names=["time", "pri", "pgn", "dst", "src", "data"],
+                  converters={
+                      "pgn": lambda x: int(x, 16),
+                      "src": lambda x: int(x, 16),
+                      "dst": lambda x: int(x, 16),
+                      "data": lambda x: len(x.split(" "))})
+
+    expected = DataFrame([[1421302965.213420, 3, 61184, 23, 40, 8],
+                          [1421302964.226776, 6, 61442, None, 71, 8]],
+                         columns=["time", "pri", "pgn",
+                                  "dst", "src", "data"])
+    expected["dst"] = expected["dst"].astype(object)
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("comment", ["#", "~", "!"])
+def test_fwf_comment(comment):
+    data = """\
+  1   2.   4  #hello world
+  5  NaN  10.0
+"""
+    data = data.replace("#", comment)
+
+    colspecs = [(0, 3), (4, 9), (9, 25)]
+    expected = DataFrame([[1, 2., 4], [5, np.nan, 10.]])
+
+    result = read_fwf(StringIO(data), colspecs=colspecs,
+                      header=None, comment=comment)
+    tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize("thousands", [",", "#", "~"])
+def test_fwf_thousands(thousands):
+    data = """\
+ 1 2,334.0    5
+10   13     10.
+"""
+    data = data.replace(",", thousands)
+
+    colspecs = [(0, 3), (3, 11), (12, 16)]
+    expected = DataFrame([[1, 2334., 5], [10, 13, 10.]])
+
+    result = read_fwf(StringIO(data), header=None,
+                      colspecs=colspecs, thousands=thousands)
+    tm.assert_almost_equal(result, expected)
+
+
+@pytest.mark.parametrize("header", [True, False])
+def test_bool_header_arg(header):
+    # see gh-6114
+    data = """\
+MyColumn
+   a
+   b
+   a
+   b"""
+
+    msg = "Passing a bool to header is invalid"
+    with pytest.raises(TypeError, match=msg):
+        read_fwf(StringIO(data), header=header)
+
+
+def test_full_file():
+    # File with all values.
+    test = """index                             A    B    C
+2000-01-03T00:00:00  0.980268513777    3  foo
+2000-01-04T00:00:00  1.04791624281    -4  bar
+2000-01-05T00:00:00  0.498580885705   73  baz
+2000-01-06T00:00:00  1.12020151869     1  foo
+2000-01-07T00:00:00  0.487094399463    0  bar
+2000-01-10T00:00:00  0.836648671666    2  baz
+2000-01-11T00:00:00  0.157160753327   34  foo"""
+    colspecs = ((0, 19), (21, 35), (38, 40), (42, 45))
+    expected = read_fwf(StringIO(test), colspecs=colspecs)
+
+    result = read_fwf(StringIO(test))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_full_file_with_missing():
+    # File with missing values.
+    test = """index                             A    B    C
+2000-01-03T00:00:00  0.980268513777    3  foo
+2000-01-04T00:00:00  1.04791624281    -4  bar
+                     0.498580885705   73  baz
+2000-01-06T00:00:00  1.12020151869     1  foo
+2000-01-07T00:00:00                    0  bar
+2000-01-10T00:00:00  0.836648671666    2  baz
+                                      34"""
+    colspecs = ((0, 19), (21, 35), (38, 40), (42, 45))
+    expected = read_fwf(StringIO(test), colspecs=colspecs)
+
+    result = read_fwf(StringIO(test))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_full_file_with_spaces():
+    # File with spaces in columns.
+    test = """
+Account                 Name  Balance     CreditLimit   AccountCreated
+101     Keanu Reeves          9315.45     10000.00           1/17/1998
+312     Gerard Butler         90.00       1000.00             8/6/2003
+868     Jennifer Love Hewitt  0           17000.00           5/25/1985
+761     Jada Pinkett-Smith    49654.87    100000.00          12/5/2006
+317     Bill Murray           789.65      5000.00             2/5/2007
+""".strip("\r\n")
+    colspecs = ((0, 7), (8, 28), (30, 38), (42, 53), (56, 70))
+    expected = read_fwf(StringIO(test), colspecs=colspecs)
+
+    result = read_fwf(StringIO(test))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_full_file_with_spaces_and_missing():
+    # File with spaces and missing values in columns.
+    test = """
+Account               Name    Balance     CreditLimit   AccountCreated
+101                           10000.00                       1/17/1998
+312     Gerard Butler         90.00       1000.00             8/6/2003
+868                                                          5/25/1985
+761     Jada Pinkett-Smith    49654.87    100000.00          12/5/2006
+317     Bill Murray           789.65
+""".strip("\r\n")
+    colspecs = ((0, 7), (8, 28), (30, 38), (42, 53), (56, 70))
+    expected = read_fwf(StringIO(test), colspecs=colspecs)
+
+    result = read_fwf(StringIO(test))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_messed_up_data():
+    # Completely messed up file.
+    test = """
+   Account          Name             Balance     Credit Limit   Account Created
+       101                           10000.00                       1/17/1998
+       312     Gerard Butler         90.00       1000.00
+
+       761     Jada Pinkett-Smith    49654.87    100000.00          12/5/2006
+  317          Bill Murray           789.65
+""".strip("\r\n")
+    colspecs = ((2, 10), (15, 33), (37, 45), (49, 61), (64, 79))
+    expected = read_fwf(StringIO(test), colspecs=colspecs)
+
+    result = read_fwf(StringIO(test))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_multiple_delimiters():
+    test = r"""
+col1~~~~~col2  col3++++++++++++++++++col4
+~~22.....11.0+++foo~~~~~~~~~~Keanu Reeves
+  33+++122.33\\\bar.........Gerard Butler
+++44~~~~12.01   baz~~Jennifer Love Hewitt
+~~55       11+++foo++++Jada Pinkett-Smith
+..66++++++.03~~~bar           Bill Murray
+""".strip("\r\n")
+    delimiter = " +~.\\"
+    colspecs = ((0, 4), (7, 13), (15, 19), (21, 41))
+    expected = read_fwf(StringIO(test), colspecs=colspecs, delimiter=delimiter)
+
+    result = read_fwf(StringIO(test), delimiter=delimiter)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_variable_width_unicode():
+    if not compat.PY3:
+        pytest.skip("Bytes-related test - only needs to work on Python 3")
+
+    data = """
+שלום שלום
+ום   שלל
+של   ום
+""".strip("\r\n")
+    encoding = "utf8"
+    kwargs = dict(header=None, encoding=encoding)
+
+    expected = read_fwf(BytesIO(data.encode(encoding)),
+                        colspecs=[(0, 4), (5, 9)], **kwargs)
+    result = read_fwf(BytesIO(data.encode(encoding)), **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [
+    dict(), {"a": "float64", "b": str, "c": "int32"}
+])
+def test_dtype(dtype):
+    data = """ a    b    c
+1    2    3.2
+3    4    5.2
+"""
+    colspecs = [(0, 5), (5, 10), (10, None)]
+    result = read_fwf(StringIO(data), colspecs=colspecs, dtype=dtype)
+
+    expected = pd.DataFrame({
+        "a": [1, 3], "b": [2, 4],
+        "c": [3.2, 5.2]}, columns=["a", "b", "c"])
+
+    for col, dt in dtype.items():
+        expected[col] = expected[col].astype(dt)
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skiprows_inference():
+    # see gh-11256
+    data = """
+Text contained in the file header
+
+DataCol1   DataCol2
+     0.0        1.0
+   101.6      956.1
+""".strip()
+    skiprows = 2
+    expected = read_csv(StringIO(data), skiprows=skiprows,
+                        delim_whitespace=True)
+
+    result = read_fwf(StringIO(data), skiprows=skiprows)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skiprows_by_index_inference():
+    data = """
+To be skipped
+Not  To  Be  Skipped
+Once more to be skipped
+123  34   8      123
+456  78   9      456
+""".strip()
+    skiprows = [0, 2]
+    expected = read_csv(StringIO(data), skiprows=skiprows,
+                        delim_whitespace=True)
+
+    result = read_fwf(StringIO(data), skiprows=skiprows)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skiprows_inference_empty():
+    data = """
+AA   BBB  C
+12   345  6
+78   901  2
+""".strip()
+
+    msg = "No rows from which to infer column width"
+    with pytest.raises(EmptyDataError, match=msg):
+        read_fwf(StringIO(data), skiprows=3)
+
+
+def test_whitespace_preservation():
+    # see gh-16772
+    header = None
+    csv_data = """
+ a ,bbb
+ cc,dd """
+
+    fwf_data = """
+ a bbb
+ ccdd """
+    result = read_fwf(StringIO(fwf_data), widths=[3, 3],
+                      header=header, skiprows=[0], delimiter="\n\t")
+    expected = read_csv(StringIO(csv_data), header=header)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_default_delimiter():
+    header = None
+    csv_data = """
+a,bbb
+cc,dd"""
+
+    fwf_data = """
+a \tbbb
+cc\tdd """
+    result = read_fwf(StringIO(fwf_data), widths=[3, 3],
+                      header=header, skiprows=[0])
+    expected = read_csv(StringIO(csv_data), header=header)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("infer", [True, False, None])
+def test_fwf_compression(compression_only, infer):
+    data = """1111111111
+    2222222222
+    3333333333""".strip()
+
+    compression = compression_only
+    extension = "gz" if compression == "gzip" else compression
+
+    kwargs = dict(widths=[5, 5], names=["one", "two"])
+    expected = read_fwf(StringIO(data), **kwargs)
+
+    if compat.PY3:
+        data = bytes(data, encoding="utf-8")
+
+    with tm.ensure_clean(filename="tmp." + extension) as path:
+        tm.write_to_compressed(compression, path, data)
+
+        if infer is not None:
+            kwargs["compression"] = "infer" if infer else compression
+
+        result = read_fwf(path, **kwargs)
+        tm.assert_frame_equal(result, expected)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_skiprows.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests that skipped rows are properly handled during
+parsing for all of the parsers defined in parsers.py
+"""
+
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.compat import StringIO, lrange, range
+from pandas.errors import EmptyDataError
+
+from pandas import DataFrame, Index
+import pandas.util.testing as tm
+
+
+@pytest.mark.parametrize("skiprows", [lrange(6), 6])
+def test_skip_rows_bug(all_parsers, skiprows):
+    # see gh-505
+    parser = all_parsers
+    text = """#foo,a,b,c
+#foo,a,b,c
+#foo,a,b,c
+#foo,a,b,c
+#foo,a,b,c
+#foo,a,b,c
+1/1/2000,1.,2.,3.
+1/2/2000,4,5,6
+1/3/2000,7,8,9
+"""
+    result = parser.read_csv(StringIO(text), skiprows=skiprows, header=None,
+                             index_col=0, parse_dates=True)
+    index = Index([datetime(2000, 1, 1), datetime(2000, 1, 2),
+                   datetime(2000, 1, 3)], name=0)
+
+    expected = DataFrame(np.arange(1., 10.).reshape((3, 3)),
+                         columns=[1, 2, 3], index=index)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_deep_skip_rows(all_parsers):
+    # see gh-4382
+    parser = all_parsers
+    data = "a,b,c\n" + "\n".join([",".join([str(i), str(i + 1), str(i + 2)])
+                                  for i in range(10)])
+    condensed_data = "a,b,c\n" + "\n".join([
+        ",".join([str(i), str(i + 1), str(i + 2)])
+        for i in [0, 1, 2, 3, 4, 6, 8, 9]])
+
+    result = parser.read_csv(StringIO(data), skiprows=[6, 8])
+    condensed_result = parser.read_csv(StringIO(condensed_data))
+    tm.assert_frame_equal(result, condensed_result)
+
+
+def test_skip_rows_blank(all_parsers):
+    # see gh-9832
+    parser = all_parsers
+    text = """#foo,a,b,c
+#foo,a,b,c
+
+#foo,a,b,c
+#foo,a,b,c
+
+1/1/2000,1.,2.,3.
+1/2/2000,4,5,6
+1/3/2000,7,8,9
+"""
+    data = parser.read_csv(StringIO(text), skiprows=6, header=None,
+                           index_col=0, parse_dates=True)
+    index = Index([datetime(2000, 1, 1), datetime(2000, 1, 2),
+                   datetime(2000, 1, 3)], name=0)
+
+    expected = DataFrame(np.arange(1., 10.).reshape((3, 3)),
+                         columns=[1, 2, 3],
+                         index=index)
+    tm.assert_frame_equal(data, expected)
+
+
+@pytest.mark.parametrize("data,kwargs,expected", [
+    ("""id,text,num_lines
+1,"line 11
+line 12",2
+2,"line 21
+line 22",2
+3,"line 31",1""",
+     dict(skiprows=[1]),
+     DataFrame([[2, "line 21\nline 22", 2],
+                [3, "line 31", 1]], columns=["id", "text", "num_lines"])),
+    ("a,b,c\n~a\n b~,~e\n d~,~f\n f~\n1,2,~12\n 13\n 14~",
+     dict(quotechar="~", skiprows=[2]),
+     DataFrame([["a\n b", "e\n d", "f\n f"]], columns=["a", "b", "c"])),
+    (("Text,url\n~example\n "
+      "sentence\n one~,url1\n~"
+      "example\n sentence\n two~,url2\n~"
+      "example\n sentence\n three~,url3"),
+     dict(quotechar="~", skiprows=[1, 3]),
+     DataFrame([['example\n sentence\n two', 'url2']],
+               columns=["Text", "url"]))
+])
+def test_skip_row_with_newline(all_parsers, data, kwargs, expected):
+    # see gh-12775 and gh-10911
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skip_row_with_quote(all_parsers):
+    # see gh-12775 and gh-10911
+    parser = all_parsers
+    data = """id,text,num_lines
+1,"line '11' line 12",2
+2,"line '21' line 22",2
+3,"line '31' line 32",1"""
+
+    exp_data = [[2, "line '21' line 22", 2],
+                [3, "line '31' line 32", 1]]
+    expected = DataFrame(exp_data, columns=[
+        "id", "text", "num_lines"])
+
+    result = parser.read_csv(StringIO(data), skiprows=[1])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("data,exp_data", [
+    ("""id,text,num_lines
+1,"line \n'11' line 12",2
+2,"line \n'21' line 22",2
+3,"line \n'31' line 32",1""",
+     [[2, "line \n'21' line 22", 2],
+      [3, "line \n'31' line 32", 1]]),
+    ("""id,text,num_lines
+1,"line '11\n' line 12",2
+2,"line '21\n' line 22",2
+3,"line '31\n' line 32",1""",
+     [[2, "line '21\n' line 22", 2],
+      [3, "line '31\n' line 32", 1]]),
+    ("""id,text,num_lines
+1,"line '11\n' \r\tline 12",2
+2,"line '21\n' \r\tline 22",2
+3,"line '31\n' \r\tline 32",1""",
+     [[2, "line '21\n' \r\tline 22", 2],
+      [3, "line '31\n' \r\tline 32", 1]]),
+])
+def test_skip_row_with_newline_and_quote(all_parsers, data, exp_data):
+    # see gh-12775 and gh-10911
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), skiprows=[1])
+
+    expected = DataFrame(exp_data, columns=["id", "text", "num_lines"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("line_terminator", [
+    "\n",    # "LF"
+    "\r\n",  # "CRLF"
+    "\r"     # "CR"
+])
+def test_skiprows_lineterminator(all_parsers, line_terminator):
+    # see gh-9079
+    parser = all_parsers
+    data = "\n".join(["SMOSMANIA ThetaProbe-ML2X ",
+                      "2007/01/01 01:00   0.2140 U M ",
+                      "2007/01/01 02:00   0.2141 M O ",
+                      "2007/01/01 04:00   0.2142 D M "])
+    expected = DataFrame([["2007/01/01", "01:00", 0.2140, "U", "M"],
+                          ["2007/01/01", "02:00", 0.2141, "M", "O"],
+                          ["2007/01/01", "04:00", 0.2142, "D", "M"]],
+                         columns=["date", "time", "var", "flag",
+                                  "oflag"])
+
+    if parser.engine == "python" and line_terminator == "\r":
+        pytest.skip("'CR' not respect with the Python parser yet")
+
+    data = data.replace("\n", line_terminator)
+    result = parser.read_csv(StringIO(data), skiprows=1, delim_whitespace=True,
+                             names=["date", "time", "var", "flag", "oflag"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skiprows_infield_quote(all_parsers):
+    # see gh-14459
+    parser = all_parsers
+    data = "a\"\nb\"\na\n1"
+    expected = DataFrame({"a": [1]})
+
+    result = parser.read_csv(StringIO(data), skiprows=2)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("kwargs,expected", [
+    (dict(), DataFrame({"1": [3, 5]})),
+    (dict(header=0, names=["foo"]), DataFrame({"foo": [3, 5]}))
+])
+def test_skip_rows_callable(all_parsers, kwargs, expected):
+    parser = all_parsers
+    data = "a\n1\n2\n3\n4\n5"
+
+    result = parser.read_csv(StringIO(data),
+                             skiprows=lambda x: x % 2 == 0,
+                             **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_skip_rows_skip_all(all_parsers):
+    parser = all_parsers
+    data = "a\n1\n2\n3\n4\n5"
+    msg = "No columns to parse from file"
+
+    with pytest.raises(EmptyDataError, match=msg):
+        parser.read_csv(StringIO(data), skiprows=lambda x: True)
+
+
+def test_skip_rows_bad_callable(all_parsers):
+    msg = "by zero"
+    parser = all_parsers
+    data = "a\n1\n2\n3\n4\n5"
+
+    with pytest.raises(ZeroDivisionError, match=msg):
+        parser.read_csv(StringIO(data), skiprows=lambda x: 1 / 0)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_textreader.py

@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests the TextReader class in parsers.pyx, which
+is integral to the C engine in parsers.py
+"""
+
+import os
+
+import numpy as np
+from numpy import nan
+import pytest
+
+import pandas._libs.parsers as parser
+from pandas._libs.parsers import TextReader
+import pandas.compat as compat
+from pandas.compat import BytesIO, StringIO, map
+
+from pandas import DataFrame
+import pandas.util.testing as tm
+from pandas.util.testing import assert_frame_equal
+
+from pandas.io.parsers import TextFileReader, read_csv
+
+
+class TestTextReader(object):
+
+    @pytest.fixture(autouse=True)
+    def setup_method(self, datapath):
+        self.dirpath = datapath('io', 'parser', 'data')
+        self.csv1 = os.path.join(self.dirpath, 'test1.csv')
+        self.csv2 = os.path.join(self.dirpath, 'test2.csv')
+        self.xls1 = os.path.join(self.dirpath, 'test.xls')
+
+    def test_file_handle(self):
+        with open(self.csv1, 'rb') as f:
+            reader = TextReader(f)
+            reader.read()
+
+    def test_string_filename(self):
+        reader = TextReader(self.csv1, header=None)
+        reader.read()
+
+    def test_file_handle_mmap(self):
+        with open(self.csv1, 'rb') as f:
+            reader = TextReader(f, memory_map=True, header=None)
+            reader.read()
+
+    def test_StringIO(self):
+        with open(self.csv1, 'rb') as f:
+            text = f.read()
+        src = BytesIO(text)
+        reader = TextReader(src, header=None)
+        reader.read()
+
+    def test_string_factorize(self):
+        # should this be optional?
+        data = 'a\nb\na\nb\na'
+        reader = TextReader(StringIO(data), header=None)
+        result = reader.read()
+        assert len(set(map(id, result[0]))) == 2
+
+    def test_skipinitialspace(self):
+        data = ('a,   b\n'
+                'a,   b\n'
+                'a,   b\n'
+                'a,   b')
+
+        reader = TextReader(StringIO(data), skipinitialspace=True,
+                            header=None)
+        result = reader.read()
+
+        tm.assert_numpy_array_equal(result[0], np.array(['a', 'a', 'a', 'a'],
+                                                        dtype=np.object_))
+        tm.assert_numpy_array_equal(result[1], np.array(['b', 'b', 'b', 'b'],
+                                                        dtype=np.object_))
+
+    def test_parse_booleans(self):
+        data = 'True\nFalse\nTrue\nTrue'
+
+        reader = TextReader(StringIO(data), header=None)
+        result = reader.read()
+
+        assert result[0].dtype == np.bool_
+
+    def test_delimit_whitespace(self):
+        data = 'a  b\na\t\t "b"\n"a"\t \t b'
+
+        reader = TextReader(StringIO(data), delim_whitespace=True,
+                            header=None)
+        result = reader.read()
+
+        tm.assert_numpy_array_equal(result[0], np.array(['a', 'a', 'a'],
+                                                        dtype=np.object_))
+        tm.assert_numpy_array_equal(result[1], np.array(['b', 'b', 'b'],
+                                                        dtype=np.object_))
+
+    def test_embedded_newline(self):
+        data = 'a\n"hello\nthere"\nthis'
+
+        reader = TextReader(StringIO(data), header=None)
+        result = reader.read()
+
+        expected = np.array(['a', 'hello\nthere', 'this'], dtype=np.object_)
+        tm.assert_numpy_array_equal(result[0], expected)
+
+    def test_euro_decimal(self):
+        data = '12345,67\n345,678'
+
+        reader = TextReader(StringIO(data), delimiter=':',
+                            decimal=',', header=None)
+        result = reader.read()
+
+        expected = np.array([12345.67, 345.678])
+        tm.assert_almost_equal(result[0], expected)
+
+    def test_integer_thousands(self):
+        data = '123,456\n12,500'
+
+        reader = TextReader(StringIO(data), delimiter=':',
+                            thousands=',', header=None)
+        result = reader.read()
+
+        expected = np.array([123456, 12500], dtype=np.int64)
+        tm.assert_almost_equal(result[0], expected)
+
+    def test_integer_thousands_alt(self):
+        data = '123.456\n12.500'
+
+        reader = TextFileReader(StringIO(data), delimiter=':',
+                                thousands='.', header=None)
+        result = reader.read()
+
+        expected = DataFrame([123456, 12500])
+        tm.assert_frame_equal(result, expected)
+
+    def test_skip_bad_lines(self, capsys):
+        # too many lines, see #2430 for why
+        data = ('a:b:c\n'
+                'd:e:f\n'
+                'g:h:i\n'
+                'j:k:l:m\n'
+                'l:m:n\n'
+                'o:p:q:r')
+
+        reader = TextReader(StringIO(data), delimiter=':',
+                            header=None)
+        msg = (r"Error tokenizing data\. C error: Expected 3 fields in"
+               " line 4, saw 4")
+        with pytest.raises(parser.ParserError, match=msg):
+            reader.read()
+
+        reader = TextReader(StringIO(data), delimiter=':',
+                            header=None,
+                            error_bad_lines=False,
+                            warn_bad_lines=False)
+        result = reader.read()
+        expected = {0: np.array(['a', 'd', 'g', 'l'], dtype=object),
+                    1: np.array(['b', 'e', 'h', 'm'], dtype=object),
+                    2: np.array(['c', 'f', 'i', 'n'], dtype=object)}
+        assert_array_dicts_equal(result, expected)
+
+        reader = TextReader(StringIO(data), delimiter=':',
+                            header=None,
+                            error_bad_lines=False,
+                            warn_bad_lines=True)
+        reader.read()
+        captured = capsys.readouterr()
+
+        assert 'Skipping line 4' in captured.err
+        assert 'Skipping line 6' in captured.err
+
+    def test_header_not_enough_lines(self):
+        data = ('skip this\n'
+                'skip this\n'
+                'a,b,c\n'
+                '1,2,3\n'
+                '4,5,6')
+
+        reader = TextReader(StringIO(data), delimiter=',', header=2)
+        header = reader.header
+        expected = [['a', 'b', 'c']]
+        assert header == expected
+
+        recs = reader.read()
+        expected = {0: np.array([1, 4], dtype=np.int64),
+                    1: np.array([2, 5], dtype=np.int64),
+                    2: np.array([3, 6], dtype=np.int64)}
+        assert_array_dicts_equal(recs, expected)
+
+    def test_escapechar(self):
+        data = ('\\"hello world\"\n'
+                '\\"hello world\"\n'
+                '\\"hello world\"')
+
+        reader = TextReader(StringIO(data), delimiter=',', header=None,
+                            escapechar='\\')
+        result = reader.read()
+        expected = {0: np.array(['"hello world"'] * 3, dtype=object)}
+        assert_array_dicts_equal(result, expected)
+
+    def test_eof_has_eol(self):
+        # handling of new line at EOF
+        pass
+
+    def test_na_substitution(self):
+        pass
+
+    def test_numpy_string_dtype(self):
+        data = """\
+a,1
+aa,2
+aaa,3
+aaaa,4
+aaaaa,5"""
+
+        def _make_reader(**kwds):
+            return TextReader(StringIO(data), delimiter=',', header=None,
+                              **kwds)
+
+        reader = _make_reader(dtype='S5,i4')
+        result = reader.read()
+
+        assert result[0].dtype == 'S5'
+
+        ex_values = np.array(['a', 'aa', 'aaa', 'aaaa', 'aaaaa'], dtype='S5')
+        assert (result[0] == ex_values).all()
+        assert result[1].dtype == 'i4'
+
+        reader = _make_reader(dtype='S4')
+        result = reader.read()
+        assert result[0].dtype == 'S4'
+        ex_values = np.array(['a', 'aa', 'aaa', 'aaaa', 'aaaa'], dtype='S4')
+        assert (result[0] == ex_values).all()
+        assert result[1].dtype == 'S4'
+
+    def test_pass_dtype(self):
+        data = """\
+one,two
+1,a
+2,b
+3,c
+4,d"""
+
+        def _make_reader(**kwds):
+            return TextReader(StringIO(data), delimiter=',', **kwds)
+
+        reader = _make_reader(dtype={'one': 'u1', 1: 'S1'})
+        result = reader.read()
+        assert result[0].dtype == 'u1'
+        assert result[1].dtype == 'S1'
+
+        reader = _make_reader(dtype={'one': np.uint8, 1: object})
+        result = reader.read()
+        assert result[0].dtype == 'u1'
+        assert result[1].dtype == 'O'
+
+        reader = _make_reader(dtype={'one': np.dtype('u1'),
+                                     1: np.dtype('O')})
+        result = reader.read()
+        assert result[0].dtype == 'u1'
+        assert result[1].dtype == 'O'
+
+    def test_usecols(self):
+        data = """\
+a,b,c
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+
+        def _make_reader(**kwds):
+            return TextReader(StringIO(data), delimiter=',', **kwds)
+
+        reader = _make_reader(usecols=(1, 2))
+        result = reader.read()
+
+        exp = _make_reader().read()
+        assert len(result) == 2
+        assert (result[1] == exp[1]).all()
+        assert (result[2] == exp[2]).all()
+
+    def test_cr_delimited(self):
+        def _test(text, **kwargs):
+            nice_text = text.replace('\r', '\r\n')
+            result = TextReader(StringIO(text), **kwargs).read()
+            expected = TextReader(StringIO(nice_text), **kwargs).read()
+            assert_array_dicts_equal(result, expected)
+
+        data = 'a,b,c\r1,2,3\r4,5,6\r7,8,9\r10,11,12'
+        _test(data, delimiter=',')
+
+        data = 'a  b  c\r1  2  3\r4  5  6\r7  8  9\r10  11  12'
+        _test(data, delim_whitespace=True)
+
+        data = 'a,b,c\r1,2,3\r4,5,6\r,88,9\r10,11,12'
+        _test(data, delimiter=',')
+
+        sample = ('A,B,C,D,E,F,G,H,I,J,K,L,M,N,O\r'
+                  'AAAAA,BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0\r'
+                  ',BBBBB,0,0,0,0,0,0,0,0,0,0,0,0,0')
+        _test(sample, delimiter=',')
+
+        data = 'A  B  C\r  2  3\r4  5  6'
+        _test(data, delim_whitespace=True)
+
+        data = 'A B C\r2 3\r4 5 6'
+        _test(data, delim_whitespace=True)
+
+    def test_empty_field_eof(self):
+        data = 'a,b,c\n1,2,3\n4,,'
+
+        result = TextReader(StringIO(data), delimiter=',').read()
+
+        expected = {0: np.array([1, 4], dtype=np.int64),
+                    1: np.array(['2', ''], dtype=object),
+                    2: np.array(['3', ''], dtype=object)}
+        assert_array_dicts_equal(result, expected)
+
+        # GH5664
+        a = DataFrame([['b'], [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]],
+                      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)
+
+            df = read_csv(StringIO('1,1,1,1,0\n' * 2 + '\n' * 2),
+                          names=list("abcd"), engine='c')
+            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)
+
+    def test_empty_csv_input(self):
+        # GH14867
+        df = read_csv(StringIO(), chunksize=20, header=None,
+                      names=['a', 'b', 'c'])
+        assert isinstance(df, TextFileReader)
+
+
+def assert_array_dicts_equal(left, right):
+    for k, v in compat.iteritems(left):
+        assert tm.assert_numpy_array_equal(np.asarray(v),
+                                           np.asarray(right[k]))

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_unsupported.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests that features that are currently unsupported in
+either the Python or C parser are actually enforced
+and are clearly communicated to the user.
+
+Ultimately, the goal is to remove test cases from this
+test suite as new feature support is added to the parsers.
+"""
+
+import pytest
+
+from pandas.compat import StringIO
+from pandas.errors import ParserError
+
+import pandas.util.testing as tm
+
+import pandas.io.parsers as parsers
+from pandas.io.parsers import read_csv
+
+
+@pytest.fixture(params=["python", "python-fwf"], ids=lambda val: val)
+def python_engine(request):
+    return request.param
+
+
+class TestUnsupportedFeatures(object):
+
+    def test_mangle_dupe_cols_false(self):
+        # see gh-12935
+        data = 'a b c\n1 2 3'
+        msg = 'is not supported'
+
+        for engine in ('c', 'python'):
+            with pytest.raises(ValueError, match=msg):
+                read_csv(StringIO(data), engine=engine,
+                         mangle_dupe_cols=False)
+
+    def test_c_engine(self):
+        # see gh-6607
+        data = 'a b c\n1 2 3'
+        msg = 'does not support'
+
+        # specify C engine with unsupported options (raise)
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), engine='c',
+                     sep=None, delim_whitespace=False)
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), engine='c', sep=r'\s')
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), engine='c', sep='\t', quotechar=chr(128))
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), engine='c', skipfooter=1)
+
+        # specify C-unsupported options without python-unsupported options
+        with tm.assert_produces_warning(parsers.ParserWarning):
+            read_csv(StringIO(data), sep=None, delim_whitespace=False)
+        with tm.assert_produces_warning(parsers.ParserWarning):
+            read_csv(StringIO(data), sep=r'\s')
+        with tm.assert_produces_warning(parsers.ParserWarning):
+            read_csv(StringIO(data), sep='\t', quotechar=chr(128))
+        with tm.assert_produces_warning(parsers.ParserWarning):
+            read_csv(StringIO(data), skipfooter=1)
+
+        text = """                      A       B       C       D        E
+one two three   four
+a   b   10.0032 5    -0.5109 -2.3358 -0.4645  0.05076  0.3640
+a   q   20      4     0.4473  1.4152  0.2834  1.00661  0.1744
+x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
+        msg = 'Error tokenizing data'
+
+        with pytest.raises(ParserError, match=msg):
+            read_csv(StringIO(text), sep='\\s+')
+        with pytest.raises(ParserError, match=msg):
+            read_csv(StringIO(text), engine='c', sep='\\s+')
+
+        msg = "Only length-1 thousands markers supported"
+        data = """A|B|C
+1|2,334|5
+10|13|10.
+"""
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), thousands=',,')
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), thousands='')
+
+        msg = "Only length-1 line terminators supported"
+        data = 'a,b,c~~1,2,3~~4,5,6'
+        with pytest.raises(ValueError, match=msg):
+            read_csv(StringIO(data), lineterminator='~~')
+
+    def test_python_engine(self, python_engine):
+        from pandas.io.parsers import _python_unsupported as py_unsupported
+
+        data = """1,2,3,,
+1,2,3,4,
+1,2,3,4,5
+1,2,,,
+1,2,3,4,"""
+
+        for default in py_unsupported:
+            msg = ('The %r option is not supported '
+                   'with the %r engine' % (default, python_engine))
+
+            kwargs = {default: object()}
+            with pytest.raises(ValueError, match=msg):
+                read_csv(StringIO(data), engine=python_engine, **kwargs)
+
+    def test_python_engine_file_no_next(self, python_engine):
+        # see gh-16530
+        class NoNextBuffer(object):
+            def __init__(self, csv_data):
+                self.data = csv_data
+
+            def __iter__(self):
+                return self
+
+            def read(self):
+                return self.data
+
+        data = "a\n1"
+        msg = "The 'python' engine cannot iterate"
+
+        with pytest.raises(ValueError, match=msg):
+            read_csv(NoNextBuffer(data), engine=python_engine)
+
+
+class TestDeprecatedFeatures(object):
+
+    @pytest.mark.parametrize("engine", ["c", "python"])
+    @pytest.mark.parametrize("kwargs", [{"tupleize_cols": True},
+                                        {"tupleize_cols": False}])
+    def test_deprecated_args(self, engine, kwargs):
+        data = "1,2,3"
+        arg, _ = list(kwargs.items())[0]
+
+        with tm.assert_produces_warning(
+                FutureWarning, check_stacklevel=False):
+            read_csv(StringIO(data), engine=engine, **kwargs)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/io/parser/test_usecols.py

@@ -0,0 +1,534 @@
+# -*- coding: utf-8 -*-
+
+"""
+Tests the usecols functionality during parsing
+for all of the parsers defined in parsers.py
+"""
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslib import Timestamp
+from pandas.compat import StringIO
+
+from pandas import DataFrame, Index
+import pandas.util.testing as tm
+
+_msg_validate_usecols_arg = ("'usecols' must either be list-like "
+                             "of all strings, all unicode, all "
+                             "integers or a callable.")
+_msg_validate_usecols_names = ("Usecols do not match columns, columns "
+                               "expected but not found: {0}")
+
+
+def test_raise_on_mixed_dtype_usecols(all_parsers):
+    # See gh-12678
+    data = """a,b,c
+        1000,2000,3000
+        4000,5000,6000
+        """
+    usecols = [0, "b", 2]
+    parser = all_parsers
+
+    with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+        parser.read_csv(StringIO(data), usecols=usecols)
+
+
+@pytest.mark.parametrize("usecols", [(1, 2), ("b", "c")])
+def test_usecols(all_parsers, usecols):
+    data = """\
+a,b,c
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), usecols=usecols)
+
+    expected = DataFrame([[2, 3], [5, 6], [8, 9],
+                          [11, 12]], columns=["b", "c"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_names(all_parsers):
+    data = """\
+a,b,c
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+    parser = all_parsers
+    names = ["foo", "bar"]
+    result = parser.read_csv(StringIO(data), names=names,
+                             usecols=[1, 2], header=0)
+
+    expected = DataFrame([[2, 3], [5, 6], [8, 9],
+                          [11, 12]], columns=names)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("names,usecols", [
+    (["b", "c"], [1, 2]),
+    (["a", "b", "c"], ["b", "c"])
+])
+def test_usecols_relative_to_names(all_parsers, names, usecols):
+    data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), names=names,
+                             header=None, usecols=usecols)
+
+    expected = DataFrame([[2, 3], [5, 6], [8, 9],
+                          [11, 12]], columns=["b", "c"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_relative_to_names2(all_parsers):
+    # see gh-5766
+    data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), names=["a", "b"],
+                             header=None, usecols=[0, 1])
+
+    expected = DataFrame([[1, 2], [4, 5], [7, 8],
+                          [10, 11]], columns=["a", "b"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_name_length_conflict(all_parsers):
+    data = """\
+1,2,3
+4,5,6
+7,8,9
+10,11,12"""
+    parser = all_parsers
+    msg = ("Number of passed names did not "
+           "match number of header fields in the file"
+           if parser.engine == "python" else
+           "Passed header names mismatches usecols")
+
+    with pytest.raises(ValueError, match=msg):
+        parser.read_csv(StringIO(data), names=["a", "b"],
+                        header=None, usecols=[1])
+
+
+def test_usecols_single_string(all_parsers):
+    # see gh-20558
+    parser = all_parsers
+    data = """foo, bar, baz
+1000, 2000, 3000
+4000, 5000, 6000"""
+
+    with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+        parser.read_csv(StringIO(data), usecols="foo")
+
+
+@pytest.mark.parametrize("data", ["a,b,c,d\n1,2,3,4\n5,6,7,8",
+                                  "a,b,c,d\n1,2,3,4,\n5,6,7,8,"])
+def test_usecols_index_col_false(all_parsers, data):
+    # see gh-9082
+    parser = all_parsers
+    usecols = ["a", "c", "d"]
+    expected = DataFrame({"a": [1, 5], "c": [3, 7], "d": [4, 8]})
+
+    result = parser.read_csv(StringIO(data), usecols=usecols, index_col=False)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("index_col", ["b", 0])
+@pytest.mark.parametrize("usecols", [["b", "c"], [1, 2]])
+def test_usecols_index_col_conflict(all_parsers, usecols, index_col):
+    # see gh-4201: test that index_col as integer reflects usecols
+    parser = all_parsers
+    data = "a,b,c,d\nA,a,1,one\nB,b,2,two"
+    expected = DataFrame({"c": [1, 2]}, index=Index(["a", "b"], name="b"))
+
+    result = parser.read_csv(StringIO(data), usecols=usecols,
+                             index_col=index_col)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_index_col_conflict2(all_parsers):
+    # see gh-4201: test that index_col as integer reflects usecols
+    parser = all_parsers
+    data = "a,b,c,d\nA,a,1,one\nB,b,2,two"
+
+    expected = DataFrame({"b": ["a", "b"], "c": [1, 2], "d": ("one", "two")})
+    expected = expected.set_index(["b", "c"])
+
+    result = parser.read_csv(StringIO(data), usecols=["b", "c", "d"],
+                             index_col=["b", "c"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_implicit_index_col(all_parsers):
+    # see gh-2654
+    parser = all_parsers
+    data = "a,b,c\n4,apple,bat,5.7\n8,orange,cow,10"
+
+    result = parser.read_csv(StringIO(data), usecols=["a", "b"])
+    expected = DataFrame({"a": ["apple", "orange"],
+                          "b": ["bat", "cow"]}, index=[4, 8])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_regex_sep(all_parsers):
+    # see gh-2733
+    parser = all_parsers
+    data = "a  b  c\n4  apple  bat  5.7\n8  orange  cow  10"
+    result = parser.read_csv(StringIO(data), sep=r"\s+", usecols=("a", "b"))
+
+    expected = DataFrame({"a": ["apple", "orange"],
+                          "b": ["bat", "cow"]}, index=[4, 8])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_whitespace(all_parsers):
+    parser = all_parsers
+    data = "a  b  c\n4  apple  bat  5.7\n8  orange  cow  10"
+
+    result = parser.read_csv(StringIO(data), delim_whitespace=True,
+                             usecols=("a", "b"))
+    expected = DataFrame({"a": ["apple", "orange"],
+                          "b": ["bat", "cow"]}, index=[4, 8])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols,expected", [
+    # 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"])),
+])
+def test_usecols_with_integer_like_header(all_parsers, usecols, expected):
+    parser = all_parsers
+    data = """2,0,1
+1000,2000,3000
+4000,5000,6000"""
+
+    result = parser.read_csv(StringIO(data), usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [[0, 2, 3], [3, 0, 2]])
+def test_usecols_with_parse_dates(all_parsers, usecols):
+    # see gh-9755
+    data = """a,b,c,d,e
+0,1,20140101,0900,4
+0,1,20140102,1000,4"""
+    parser = all_parsers
+    parse_dates = [[1, 2]]
+
+    cols = {
+        "a": [0, 0],
+        "c_d": [
+            Timestamp("2014-01-01 09:00:00"),
+            Timestamp("2014-01-02 10:00:00")
+        ]
+    }
+    expected = DataFrame(cols, columns=["c_d", "a"])
+    result = parser.read_csv(StringIO(data), usecols=usecols,
+                             parse_dates=parse_dates)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates2(all_parsers):
+    # see gh-13604
+    parser = all_parsers
+    data = """2008-02-07 09:40,1032.43
+2008-02-07 09:50,1042.54
+2008-02-07 10:00,1051.65"""
+
+    names = ["date", "values"]
+    usecols = names[:]
+    parse_dates = [0]
+
+    index = Index([Timestamp("2008-02-07 09:40"),
+                   Timestamp("2008-02-07 09:50"),
+                   Timestamp("2008-02-07 10:00")],
+                  name="date")
+    cols = {"values": [1032.43, 1042.54, 1051.65]}
+    expected = DataFrame(cols, index=index)
+
+    result = parser.read_csv(StringIO(data), parse_dates=parse_dates,
+                             index_col=0, usecols=usecols,
+                             header=None, names=names)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates3(all_parsers):
+    # see gh-14792
+    parser = all_parsers
+    data = """a,b,c,d,e,f,g,h,i,j
+2016/09/21,1,1,2,3,4,5,6,7,8"""
+
+    usecols = list("abcdefghij")
+    parse_dates = [0]
+
+    cols = {"a": Timestamp("2016-09-21"),
+            "b": [1], "c": [1], "d": [2],
+            "e": [3], "f": [4], "g": [5],
+            "h": [6], "i": [7], "j": [8]}
+    expected = DataFrame(cols, columns=usecols)
+
+    result = parser.read_csv(StringIO(data), usecols=usecols,
+                             parse_dates=parse_dates)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_parse_dates4(all_parsers):
+    data = "a,b,c,d,e,f,g,h,i,j\n2016/09/21,1,1,2,3,4,5,6,7,8"
+    usecols = list("abcdefghij")
+    parse_dates = [[0, 1]]
+    parser = all_parsers
+
+    cols = {"a_b": "2016/09/21 1",
+            "c": [1], "d": [2], "e": [3], "f": [4],
+            "g": [5], "h": [6], "i": [7], "j": [8]}
+    expected = DataFrame(cols, columns=["a_b"] + list("cdefghij"))
+
+    result = parser.read_csv(StringIO(data), usecols=usecols,
+                             parse_dates=parse_dates)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [[0, 2, 3], [3, 0, 2]])
+@pytest.mark.parametrize("names", [
+    list("abcde"),  # Names span all columns in original data.
+    list("acd"),    # Names span only the selected columns.
+])
+def test_usecols_with_parse_dates_and_names(all_parsers, usecols, names):
+    # see gh-9755
+    s = """0,1,20140101,0900,4
+0,1,20140102,1000,4"""
+    parse_dates = [[1, 2]]
+    parser = all_parsers
+
+    cols = {
+        "a": [0, 0],
+        "c_d": [
+            Timestamp("2014-01-01 09:00:00"),
+            Timestamp("2014-01-02 10:00:00")
+        ]
+    }
+    expected = DataFrame(cols, columns=["c_d", "a"])
+
+    result = parser.read_csv(StringIO(s), names=names,
+                             parse_dates=parse_dates,
+                             usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_unicode_strings(all_parsers):
+    # see gh-13219
+    data = """AAA,BBB,CCC,DDD
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+    parser = all_parsers
+
+    exp_data = {
+        "AAA": {
+            0: 0.056674972999999997,
+            1: 2.6132309819999997,
+            2: 3.5689350380000002
+        },
+        "BBB": {0: 8, 1: 2, 2: 7}
+    }
+    expected = DataFrame(exp_data)
+
+    result = parser.read_csv(StringIO(data), usecols=[u"AAA", u"BBB"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_usecols_with_single_byte_unicode_strings(all_parsers):
+    # see gh-13219
+    data = """A,B,C,D
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+    parser = all_parsers
+
+    exp_data = {
+        "A": {
+            0: 0.056674972999999997,
+            1: 2.6132309819999997,
+            2: 3.5689350380000002
+        },
+        "B": {0: 8, 1: 2, 2: 7}
+    }
+    expected = DataFrame(exp_data)
+
+    result = parser.read_csv(StringIO(data), usecols=[u"A", u"B"])
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [[u"AAA", b"BBB"], [b"AAA", u"BBB"]])
+def test_usecols_with_mixed_encoding_strings(all_parsers, usecols):
+    data = """AAA,BBB,CCC,DDD
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+    parser = all_parsers
+
+    with pytest.raises(ValueError, match=_msg_validate_usecols_arg):
+        parser.read_csv(StringIO(data), usecols=usecols)
+
+
+@pytest.mark.parametrize("usecols", [
+    ["あああ", "いい"],
+    [u"あああ", u"いい"]
+])
+def test_usecols_with_multi_byte_characters(all_parsers, usecols):
+    data = """あああ,いい,ううう,ええええ
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+    parser = all_parsers
+
+    exp_data = {
+        "あああ": {
+            0: 0.056674972999999997,
+            1: 2.6132309819999997,
+            2: 3.5689350380000002
+        },
+        "いい": {0: 8, 1: 2, 2: 7}
+    }
+    expected = DataFrame(exp_data)
+
+    result = parser.read_csv(StringIO(data), usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_empty_usecols(all_parsers):
+    data = "a,b,c\n1,2,3\n4,5,6"
+    expected = DataFrame()
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(data), usecols=set())
+    tm.assert_frame_equal(result, expected)
+
+
+def test_np_array_usecols(all_parsers):
+    # see gh-12546
+    parser = all_parsers
+    data = "a,b,c\n1,2,3"
+    usecols = np.array(["a", "b"])
+
+    expected = DataFrame([[1, 2]], columns=usecols)
+    result = parser.read_csv(StringIO(data), usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols,expected", [
+    (lambda x: x.upper() in ["AAA", "BBB", "DDD"],
+     DataFrame({
+         "AaA": {
+             0: 0.056674972999999997,
+             1: 2.6132309819999997,
+             2: 3.5689350380000002
+         },
+         "bBb": {0: 8, 1: 2, 2: 7},
+         "ddd": {0: "a", 1: "b", 2: "a"}
+     })),
+    (lambda x: False, DataFrame()),
+])
+def test_callable_usecols(all_parsers, usecols, expected):
+    # see gh-14154
+    data = """AaA,bBb,CCC,ddd
+0.056674973,8,True,a
+2.613230982,2,False,b
+3.568935038,7,False,a"""
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(data), usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols", [["a", "c"], lambda x: x in ["a", "c"]])
+def test_incomplete_first_row(all_parsers, usecols):
+    # see gh-6710
+    data = "1,2\n1,2,3"
+    parser = all_parsers
+    names = ["a", "b", "c"]
+    expected = DataFrame({"a": [1, 1], "c": [np.nan, 3]})
+
+    result = parser.read_csv(StringIO(data), names=names, usecols=usecols)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("data,usecols,kwargs,expected", [
+    # see gh-8985
+    ("19,29,39\n" * 2 + "10,20,30,40", [0, 1, 2],
+     dict(header=None), DataFrame([[19, 29, 39], [19, 29, 39], [10, 20, 30]])),
+
+    # see gh-9549
+    (("A,B,C\n1,2,3\n3,4,5\n1,2,4,5,1,6\n"
+      "1,2,3,,,1,\n1,2,3\n5,6,7"), ["A", "B", "C"],
+     dict(), DataFrame({"A": [1, 3, 1, 1, 1, 5],
+                        "B": [2, 4, 2, 2, 2, 6],
+                        "C": [3, 5, 4, 3, 3, 7]})),
+])
+def test_uneven_length_cols(all_parsers, data, usecols, kwargs, expected):
+    # see gh-8985
+    parser = all_parsers
+    result = parser.read_csv(StringIO(data), usecols=usecols, **kwargs)
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("usecols,kwargs,expected,msg", [
+    (["a", "b", "c", "d"], dict(),
+     DataFrame({"a": [1, 5], "b": [2, 6], "c": [3, 7], "d": [4, 8]}), None),
+    (["a", "b", "c", "f"], dict(), None,
+     _msg_validate_usecols_names.format(r"\['f'\]")),
+    (["a", "b", "f"], dict(), None,
+     _msg_validate_usecols_names.format(r"\['f'\]")),
+    (["a", "b", "f", "g"], dict(), None,
+     _msg_validate_usecols_names.format(r"\[('f', 'g'|'g', 'f')\]")),
+
+    # see gh-14671
+    (None, dict(header=0, names=["A", "B", "C", "D"]),
+     DataFrame({"A": [1, 5], "B": [2, 6], "C": [3, 7],
+                "D": [4, 8]}), None),
+    (["A", "B", "C", "f"], dict(header=0, names=["A", "B", "C", "D"]),
+     None, _msg_validate_usecols_names.format(r"\['f'\]")),
+    (["A", "B", "f"], dict(names=["A", "B", "C", "D"]),
+     None, _msg_validate_usecols_names.format(r"\['f'\]")),
+])
+def test_raises_on_usecols_names_mismatch(all_parsers, usecols,
+                                          kwargs, expected, msg):
+    data = "a,b,c,d\n1,2,3,4\n5,6,7,8"
+    kwargs.update(usecols=usecols)
+    parser = all_parsers
+
+    if expected is None:
+        with pytest.raises(ValueError, match=msg):
+            parser.read_csv(StringIO(data), **kwargs)
+    else:
+        result = parser.read_csv(StringIO(data), **kwargs)
+        tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.xfail(
+    reason="see gh-16469: works on the C engine but not the Python engine",
+    strict=False)
+@pytest.mark.parametrize("usecols", [["A", "C"], [0, 2]])
+def test_usecols_subset_names_mismatch_orig_columns(all_parsers, usecols):
+    data = "a,b,c,d\n1,2,3,4\n5,6,7,8"
+    names = ["A", "B", "C", "D"]
+    parser = all_parsers
+
+    result = parser.read_csv(StringIO(data), header=0,
+                             names=names, usecols=usecols)
+    expected = DataFrame({"A": [1, 5], "C": [3, 7]})
+    tm.assert_frame_equal(result, expected)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/series/test_duplicates.py

@@ -0,0 +1,148 @@
+# coding=utf-8
+
+import numpy as np
+import pytest
+
+from pandas import Categorical, Series
+import pandas.util.testing as tm
+
+
+def test_value_counts_nunique():
+    # basics.rst doc example
+    series = Series(np.random.randn(500))
+    series[20:500] = np.nan
+    series[10:20] = 5000
+    result = series.nunique()
+    assert result == 11
+
+    # GH 18051
+    s = Series(Categorical([]))
+    assert s.nunique() == 0
+    s = Series(Categorical([np.nan]))
+    assert s.nunique() == 0
+
+
+def test_unique():
+    # GH714 also, dtype=float
+    s = Series([1.2345] * 100)
+    s[::2] = np.nan
+    result = s.unique()
+    assert len(result) == 2
+
+    s = Series([1.2345] * 100, dtype='f4')
+    s[::2] = np.nan
+    result = s.unique()
+    assert len(result) == 2
+
+    # NAs in object arrays #714
+    s = Series(['foo'] * 100, dtype='O')
+    s[::2] = np.nan
+    result = s.unique()
+    assert len(result) == 2
+
+    # decision about None
+    s = Series([1, 2, 3, None, None, None], dtype=object)
+    result = s.unique()
+    expected = np.array([1, 2, 3, None], dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+    # GH 18051
+    s = Series(Categorical([]))
+    tm.assert_categorical_equal(s.unique(), Categorical([]), check_dtype=False)
+    s = Series(Categorical([np.nan]))
+    tm.assert_categorical_equal(s.unique(), Categorical([np.nan]),
+                                check_dtype=False)
+
+
+def test_unique_data_ownership():
+    # it works! #1807
+    Series(Series(["a", "c", "b"]).unique()).sort_values()
+
+
+@pytest.mark.parametrize('data, expected', [
+    (np.random.randint(0, 10, size=1000), False),
+    (np.arange(1000), True),
+    ([], True),
+    ([np.nan], True),
+    (['foo', 'bar', np.nan], True),
+    (['foo', 'foo', np.nan], False),
+    (['foo', 'bar', np.nan, np.nan], False)])
+def test_is_unique(data, expected):
+    # GH11946 / GH25180
+    s = Series(data)
+    assert s.is_unique is expected
+
+
+def test_is_unique_class_ne(capsys):
+    # GH 20661
+    class Foo(object):
+        def __init__(self, val):
+            self._value = val
+
+        def __ne__(self, other):
+            raise Exception("NEQ not supported")
+
+    with capsys.disabled():
+        li = [Foo(i) for i in range(5)]
+        s = Series(li, index=[i for i in 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)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/series/test_internals.py

@@ -0,0 +1,343 @@
+# coding=utf-8
+# pylint: disable-msg=E1101,W0612
+
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import NaT, Series, Timestamp
+from pandas.core.internals.blocks import IntBlock
+import pandas.util.testing as tm
+from pandas.util.testing import assert_series_equal
+
+
+class TestSeriesInternals(object):
+
+    def test_convert_objects(self):
+
+        s = Series([1., 2, 3], index=['a', 'b', 'c'])
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates=False,
+                                       convert_numeric=True)
+        assert_series_equal(result, s)
+
+        # force numeric conversion
+        r = s.copy().astype('O')
+        r['a'] = '1'
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False,
+                                       convert_numeric=True)
+        assert_series_equal(result, s)
+
+        r = s.copy().astype('O')
+        r['a'] = '1.'
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False,
+                                       convert_numeric=True)
+        assert_series_equal(result, s)
+
+        r = s.copy().astype('O')
+        r['a'] = 'garbled'
+        expected = s.copy()
+        expected['a'] = np.nan
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False,
+                                       convert_numeric=True)
+        assert_series_equal(result, expected)
+
+        # GH 4119, not converting a mixed type (e.g.floats and object)
+        s = Series([1, 'na', 3, 4])
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_numeric=True)
+        expected = Series([1, np.nan, 3, 4])
+        assert_series_equal(result, expected)
+
+        s = Series([1, '', 3, 4])
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_numeric=True)
+        expected = Series([1, np.nan, 3, 4])
+        assert_series_equal(result, expected)
+
+        # dates
+        s = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0),
+                    datetime(2001, 1, 3, 0, 0)])
+        s2 = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0),
+                     datetime(2001, 1, 3, 0, 0), 'foo', 1.0, 1,
+                     Timestamp('20010104'), '20010105'],
+                    dtype='O')
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates=True,
+                                       convert_numeric=False)
+        expected = Series([Timestamp('20010101'), Timestamp('20010102'),
+                           Timestamp('20010103')], dtype='M8[ns]')
+        assert_series_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=True)
+        assert_series_equal(result, expected)
+
+        expected = Series([Timestamp('20010101'), Timestamp('20010102'),
+                           Timestamp('20010103'),
+                           NaT, NaT, NaT, Timestamp('20010104'),
+                           Timestamp('20010105')], dtype='M8[ns]')
+        with tm.assert_produces_warning(FutureWarning):
+            result = s2.convert_objects(convert_dates='coerce',
+                                        convert_numeric=False)
+        assert_series_equal(result, expected)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s2.convert_objects(convert_dates='coerce',
+                                        convert_numeric=True)
+        assert_series_equal(result, expected)
+
+        # preserver all-nans (if convert_dates='coerce')
+        s = Series(['foo', 'bar', 1, 1.0], dtype='O')
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
+        expected = Series([NaT] * 2 + [Timestamp(1)] * 2)
+        assert_series_equal(result, expected)
+
+        # preserver if non-object
+        s = Series([1], dtype='float32')
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
+        assert_series_equal(result, s)
+
+        # r = s.copy()
+        # r[0] = np.nan
+        # result = r.convert_objects(convert_dates=True,convert_numeric=False)
+        # assert result.dtype == 'M8[ns]'
+
+        # dateutil parses some single letters into today's value as a date
+        for x in 'abcdefghijklmnopqrstuvwxyz':
+            s = Series([x])
+            with tm.assert_produces_warning(FutureWarning):
+                result = s.convert_objects(convert_dates='coerce')
+            assert_series_equal(result, s)
+            s = Series([x.upper()])
+            with tm.assert_produces_warning(FutureWarning):
+                result = s.convert_objects(convert_dates='coerce')
+            assert_series_equal(result, s)
+
+    def test_convert_objects_preserve_bool(self):
+        s = Series([1, True, 3, 5], dtype=object)
+        with tm.assert_produces_warning(FutureWarning):
+            r = s.convert_objects(convert_numeric=True)
+        e = Series([1, 1, 3, 5], dtype='i8')
+        tm.assert_series_equal(r, e)
+
+    def test_convert_objects_preserve_all_bool(self):
+        s = Series([False, True, False, False], dtype=object)
+        with tm.assert_produces_warning(FutureWarning):
+            r = s.convert_objects(convert_numeric=True)
+        e = Series([False, True, False, False], dtype=bool)
+        tm.assert_series_equal(r, e)
+
+    # GH 10265
+    def test_convert(self):
+        # Tests: All to nans, coerce, true
+        # Test coercion returns correct type
+        s = Series(['a', 'b', 'c'])
+        results = s._convert(datetime=True, coerce=True)
+        expected = Series([NaT] * 3)
+        assert_series_equal(results, expected)
+
+        results = s._convert(numeric=True, coerce=True)
+        expected = Series([np.nan] * 3)
+        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)
+
+        dt = datetime(2001, 1, 1, 0, 0)
+        td = dt - datetime(2000, 1, 1, 0, 0)
+
+        # Test coercion with mixed types
+        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)
+
+        results = s._convert(numeric=True, coerce=True)
+        expected = Series([np.nan, 3.1415, np.nan, np.nan])
+        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)
+
+        # Test standard conversion returns original
+        results = s._convert(datetime=True)
+        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)
+        results = s._convert(timedelta=True)
+        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)
+        results = s._convert(True, False, True)
+        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)
+        results = s._convert(datetime=False, numeric=True, timedelta=True)
+        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)
+        results = s._convert(True, True, False)
+        assert_series_equal(results, s)
+
+        s = Series([1., 2, 3], index=['a', 'b', 'c'])
+        result = s._convert(numeric=True)
+        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)
+
+        r = s.copy().astype('O')
+        r['a'] = '1.'
+        result = r._convert(numeric=True)
+        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)
+
+        # 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)
+
+        s = Series([1, '', 3, 4])
+        result = s._convert(datetime=True, numeric=True)
+        assert_series_equal(result, expected)
+
+        # dates
+        s = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0),
+                    datetime(2001, 1, 3, 0, 0)])
+        s2 = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0),
+                     datetime(2001, 1, 3, 0, 0), 'foo', 1.0, 1,
+                     Timestamp('20010104'), '20010105'], dtype='O')
+
+        result = s._convert(datetime=True)
+        expected = Series([Timestamp('20010101'), Timestamp('20010102'),
+                           Timestamp('20010103')], dtype='M8[ns]')
+        assert_series_equal(result, expected)
+
+        result = s._convert(datetime=True, coerce=True)
+        assert_series_equal(result, expected)
+
+        expected = Series([Timestamp('20010101'), Timestamp('20010102'),
+                           Timestamp('20010103'), NaT, NaT, NaT,
+                           Timestamp('20010104'), Timestamp('20010105')],
+                          dtype='M8[ns]')
+        result = s2._convert(datetime=True, numeric=False, timedelta=False,
+                             coerce=True)
+        assert_series_equal(result, expected)
+        result = s2._convert(datetime=True, coerce=True)
+        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)
+
+        # preserver if non-object
+        s = Series([1], dtype='float32')
+        result = s._convert(datetime=True, coerce=True)
+        assert_series_equal(result, s)
+
+        # r = s.copy()
+        # r[0] = np.nan
+        # result = r._convert(convert_dates=True,convert_numeric=False)
+        # assert result.dtype == 'M8[ns]'
+
+        # dateutil parses some single letters into today's value as a date
+        expected = Series([NaT])
+        for x in 'abcdefghijklmnopqrstuvwxyz':
+            s = Series([x])
+            result = s._convert(datetime=True, coerce=True)
+            assert_series_equal(result, expected)
+            s = Series([x.upper()])
+            result = s._convert(datetime=True, coerce=True)
+            assert_series_equal(result, expected)
+
+    def test_convert_no_arg_error(self):
+        s = Series(['1.0', '2'])
+        msg = r"At least one of datetime, numeric or timedelta must be True\."
+        with pytest.raises(ValueError, match=msg):
+            s._convert()
+
+    def test_convert_preserve_bool(self):
+        s = Series([1, True, 3, 5], dtype=object)
+        r = s._convert(datetime=True, numeric=True)
+        e = Series([1, 1, 3, 5], dtype='i8')
+        tm.assert_series_equal(r, e)
+
+    def test_convert_preserve_all_bool(self):
+        s = Series([False, True, False, False], dtype=object)
+        r = s._convert(datetime=True, numeric=True)
+        e = Series([False, True, False, False], dtype=bool)
+        tm.assert_series_equal(r, e)
+
+    def test_constructor_no_pandas_array(self):
+        ser = pd.Series([1, 2, 3])
+        result = pd.Series(ser.array)
+        tm.assert_series_equal(ser, result)
+        assert isinstance(result._data.blocks[0], IntBlock)
+
+    def test_from_array(self):
+        result = pd.Series(pd.array(['1H', '2H'], dtype='timedelta64[ns]'))
+        assert result._data.blocks[0].is_extension is False
+
+        result = pd.Series(pd.array(['2015'], dtype='datetime64[ns]'))
+        assert result._data.blocks[0].is_extension is False
+
+    def test_from_list_dtype(self):
+        result = pd.Series(['1H', '2H'], dtype='timedelta64[ns]')
+        assert result._data.blocks[0].is_extension is False
+
+        result = pd.Series(['2015'], dtype='datetime64[ns]')
+        assert result._data.blocks[0].is_extension is False
+
+
+def test_hasnans_unchached_for_series():
+    # GH#19700
+    idx = pd.Index([0, 1])
+    assert idx.hasnans is False
+    assert 'hasnans' in idx._cache
+    ser = idx.to_series()
+    assert ser.hasnans is False
+    assert not hasattr(ser, '_cache')
+    ser.iloc[-1] = np.nan
+    assert ser.hasnans is True
+    assert Series.hasnans.__doc__ == pd.Index.hasnans.__doc__

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/series/test_io.py

@@ -0,0 +1,267 @@
+# coding=utf-8
+# pylint: disable-msg=E1101,W0612
+
+import collections
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.compat import StringIO, u
+
+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)
+
+from pandas.io.common import _get_handle
+
+
+class TestSeriesToCSV():
+
+    def read_csv(self, path, **kwargs):
+        params = dict(squeeze=True, index_col=0,
+                      header=None, parse_dates=True)
+        params.update(**kwargs)
+
+        header = params.get("header")
+        out = pd.read_csv(path, **params)
+
+        if header is None:
+            out.name = out.index.name = None
+
+        return out
+
+    def test_from_csv_deprecation(self, datetime_series):
+        # see gh-17812
+        with ensure_clean() as path:
+            datetime_series.to_csv(path, header=False)
+
+            with tm.assert_produces_warning(FutureWarning,
+                                            check_stacklevel=False):
+                ts = self.read_csv(path)
+                depr_ts = Series.from_csv(path)
+                assert_series_equal(depr_ts, ts)
+
+    @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:
+            datetime_series.to_csv(path, header=False)
+            ts = self.read_csv(path)
+            assert_series_equal(datetime_series, ts, check_names=False)
+
+            assert ts.name is None
+            assert ts.index.name is None
+
+            with tm.assert_produces_warning(FutureWarning,
+                                            check_stacklevel=False):
+                depr_ts = Series.from_csv(path)
+                assert_series_equal(depr_ts, ts)
+
+            # see gh-10483
+            datetime_series.to_csv(path, header=True)
+            ts_h = self.read_csv(path, header=0)
+            assert ts_h.name == "ts"
+
+            string_series.to_csv(path, header=False)
+            series = self.read_csv(path)
+            assert_series_equal(string_series, series, check_names=False)
+
+            assert series.name is None
+            assert series.index.name is None
+
+            string_series.to_csv(path, header=True)
+            series_h = self.read_csv(path, header=0)
+            assert series_h.name == "series"
+
+            with open(path, "w") as outfile:
+                outfile.write("1998-01-01|1.0\n1999-01-01|2.0")
+
+            series = self.read_csv(path, sep="|")
+            check_series = Series({datetime(1998, 1, 1): 1.0,
+                                   datetime(1999, 1, 1): 2.0})
+            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)
+
+    def test_to_csv(self, datetime_series):
+        import io
+
+        with ensure_clean() as path:
+            datetime_series.to_csv(path, header=False)
+
+            with io.open(path, newline=None) as f:
+                lines = f.readlines()
+            assert (lines[1] != '\n')
+
+            datetime_series.to_csv(path, index=False, header=False)
+            arr = np.loadtxt(path)
+            assert_almost_equal(arr, datetime_series.values)
+
+    def test_to_csv_unicode_index(self):
+        buf = StringIO()
+        s = Series([u("\u05d0"), "d2"], index=[u("\u05d0"), u("\u05d1")])
+
+        s.to_csv(buf, encoding="UTF-8", header=False)
+        buf.seek(0)
+
+        s2 = self.read_csv(buf, index_col=0, encoding="UTF-8")
+        assert_series_equal(s, s2)
+
+    def test_to_csv_float_format(self):
+
+        with 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)
+
+    def test_to_csv_list_entries(self):
+        s = Series(['jack and jill', 'jesse and frank'])
+
+        split = s.str.split(r'\s+and\s+')
+
+        buf = StringIO()
+        split.to_csv(buf, header=False)
+
+    def test_to_csv_path_is_none(self):
+        # GH 8215
+        # Series.to_csv() was returning None, inconsistent with
+        # DataFrame.to_csv() which returned string
+        s = Series([1, 2, 3])
+        csv_str = s.to_csv(path_or_buf=None, header=False)
+        assert isinstance(csv_str, str)
+
+    @pytest.mark.parametrize('s,encoding', [
+        (Series([0.123456, 0.234567, 0.567567], index=['A', 'B', 'C'],
+                name='X'), None),
+        # GH 21241, 21118
+        (Series(['abc', 'def', 'ghi'], name='X'), 'ascii'),
+        (Series(["123", u"你好", u"世界"], name=u"中文"), 'gb2312'),
+        (Series(["123", u"Γειά σου", u"Κόσμε"], name=u"Ελληνικά"), 'cp737')
+    ])
+    def test_to_csv_compression(self, s, encoding, compression):
+
+        with ensure_clean() as filename:
+
+            s.to_csv(filename, compression=compression, encoding=encoding,
+                     header=True)
+            # test the round trip - to_csv -> read_csv
+            result = pd.read_csv(filename, compression=compression,
+                                 encoding=encoding, index_col=0, squeeze=True)
+            assert_series_equal(s, result)
+
+            # test the round trip using file handle - to_csv -> read_csv
+            f, _handles = _get_handle(filename, 'w', compression=compression,
+                                      encoding=encoding)
+            with f:
+                s.to_csv(f, encoding=encoding, header=True)
+            result = pd.read_csv(filename, compression=compression,
+                                 encoding=encoding, index_col=0, squeeze=True)
+            assert_series_equal(s, result)
+
+            # explicitly ensure file was compressed
+            with tm.decompress_file(filename, compression) as fh:
+                text = fh.read().decode(encoding or 'utf8')
+                assert s.name in text
+
+            with tm.decompress_file(filename, compression) as fh:
+                assert_series_equal(s, pd.read_csv(fh,
+                                                   index_col=0,
+                                                   squeeze=True,
+                                                   encoding=encoding))
+
+
+class TestSeriesIO():
+
+    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)
+
+        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)
+
+        rs = datetime_series.to_frame(name='testdifferent')
+        xp = pd.DataFrame(dict(testdifferent=datetime_series.values),
+                          index=datetime_series.index)
+        assert_frame_equal(rs, xp)
+
+    def test_timeseries_periodindex(self):
+        # GH2891
+        from pandas import period_range
+        prng = period_range('1/1/2011', '1/1/2012', freq='M')
+        ts = Series(np.random.randn(len(prng)), prng)
+        new_ts = tm.round_trip_pickle(ts)
+        assert new_ts.index.freq == 'M'
+
+    def test_pickle_preserve_name(self):
+        for n in [777, 777., 'name', datetime(2001, 11, 11), (1, 2)]:
+            unpickled = self._pickle_roundtrip_name(tm.makeTimeSeries(name=n))
+            assert unpickled.name == n
+
+    def _pickle_roundtrip_name(self, obj):
+
+        with ensure_clean() as path:
+            obj.to_pickle(path)
+            unpickled = pd.read_pickle(path)
+            return unpickled
+
+    def test_to_frame_expanddim(self):
+        # GH 9762
+
+        class SubclassedSeries(Series):
+
+            @property
+            def _constructor_expanddim(self):
+                return SubclassedFrame
+
+        class SubclassedFrame(DataFrame):
+            pass
+
+        s = SubclassedSeries([1, 2, 3], name='X')
+        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.iteritems()))
+        tm.assert_series_equal(from_method, from_constructor)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/sparse/test_pivot.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+import pandas as pd
+import pandas.util.testing as tm
+
+
+class TestPivotTable(object):
+
+    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_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)
+
+        # ToDo: sum doesn't handle nan properly
+        # 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)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/sparse/test_reshape.py

@@ -0,0 +1,42 @@
+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)])
+
+
+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)
+
+
+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)
+
+
+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)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tools/test_numeric.py

@@ -0,0 +1,440 @@
+import decimal
+
+import numpy as np
+from numpy import iinfo
+import pytest
+
+import pandas as pd
+from pandas import to_numeric
+from pandas.util import testing as tm
+
+
+class TestToNumeric(object):
+
+    def test_empty(self):
+        # see gh-16302
+        s = pd.Series([], dtype=object)
+
+        res = to_numeric(s)
+        expected = pd.Series([], dtype=np.int64)
+
+        tm.assert_series_equal(res, expected)
+
+        # Original issue example
+        res = to_numeric(s, errors='coerce', downcast='integer')
+        expected = pd.Series([], dtype=np.int8)
+
+        tm.assert_series_equal(res, expected)
+
+    def test_series(self):
+        s = pd.Series(['1', '-3.14', '7'])
+        res = to_numeric(s)
+        expected = pd.Series([1, -3.14, 7])
+        tm.assert_series_equal(res, expected)
+
+        s = pd.Series(['1', '-3.14', 7])
+        res = to_numeric(s)
+        tm.assert_series_equal(res, expected)
+
+    def test_series_numeric(self):
+        s = pd.Series([1, 3, 4, 5], index=list('ABCD'), name='XXX')
+        res = to_numeric(s)
+        tm.assert_series_equal(res, s)
+
+        s = pd.Series([1., 3., 4., 5.], index=list('ABCD'), name='XXX')
+        res = to_numeric(s)
+        tm.assert_series_equal(res, s)
+
+        # bool is regarded as numeric
+        s = pd.Series([True, False, True, True],
+                      index=list('ABCD'), name='XXX')
+        res = to_numeric(s)
+        tm.assert_series_equal(res, s)
+
+    def test_error(self):
+        s = pd.Series([1, -3.14, 'apple'])
+        msg = 'Unable to parse string "apple" at position 2'
+        with pytest.raises(ValueError, match=msg):
+            to_numeric(s, errors='raise')
+
+        res = to_numeric(s, errors='ignore')
+        expected = pd.Series([1, -3.14, 'apple'])
+        tm.assert_series_equal(res, expected)
+
+        res = to_numeric(s, errors='coerce')
+        expected = pd.Series([1, -3.14, np.nan])
+        tm.assert_series_equal(res, expected)
+
+        s = pd.Series(['orange', 1, -3.14, 'apple'])
+        msg = 'Unable to parse string "orange" at position 0'
+        with pytest.raises(ValueError, match=msg):
+            to_numeric(s, errors='raise')
+
+    def test_error_seen_bool(self):
+        s = pd.Series([True, False, 'apple'])
+        msg = 'Unable to parse string "apple" at position 2'
+        with pytest.raises(ValueError, match=msg):
+            to_numeric(s, errors='raise')
+
+        res = to_numeric(s, errors='ignore')
+        expected = pd.Series([True, False, 'apple'])
+        tm.assert_series_equal(res, expected)
+
+        # coerces to float
+        res = to_numeric(s, errors='coerce')
+        expected = pd.Series([1., 0., np.nan])
+        tm.assert_series_equal(res, expected)
+
+    def test_list(self):
+        s = ['1', '-3.14', '7']
+        res = to_numeric(s)
+        expected = np.array([1, -3.14, 7])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_list_numeric(self):
+        s = [1, 3, 4, 5]
+        res = to_numeric(s)
+        tm.assert_numpy_array_equal(res, np.array(s, dtype=np.int64))
+
+        s = [1., 3., 4., 5.]
+        res = to_numeric(s)
+        tm.assert_numpy_array_equal(res, np.array(s))
+
+        # bool is regarded as numeric
+        s = [True, False, True, True]
+        res = to_numeric(s)
+        tm.assert_numpy_array_equal(res, np.array(s))
+
+    def test_numeric(self):
+        s = pd.Series([1, -3.14, 7], dtype='O')
+        res = to_numeric(s)
+        expected = pd.Series([1, -3.14, 7])
+        tm.assert_series_equal(res, expected)
+
+        s = pd.Series([1, -3.14, 7])
+        res = to_numeric(s)
+        tm.assert_series_equal(res, expected)
+
+        # GH 14827
+        df = pd.DataFrame(dict(
+            a=[1.2, decimal.Decimal(3.14), decimal.Decimal("infinity"), '0.1'],
+            b=[1.0, 2.0, 3.0, 4.0],
+        ))
+        expected = pd.DataFrame(dict(
+            a=[1.2, 3.14, np.inf, 0.1],
+            b=[1.0, 2.0, 3.0, 4.0],
+        ))
+
+        # Test to_numeric over one column
+        df_copy = df.copy()
+        df_copy['a'] = df_copy['a'].apply(to_numeric)
+        tm.assert_frame_equal(df_copy, expected)
+
+        # Test to_numeric over multiple columns
+        df_copy = df.copy()
+        df_copy[['a', 'b']] = df_copy[['a', 'b']].apply(to_numeric)
+        tm.assert_frame_equal(df_copy, expected)
+
+    def test_numeric_lists_and_arrays(self):
+        # Test to_numeric with embedded lists and arrays
+        df = pd.DataFrame(dict(
+            a=[[decimal.Decimal(3.14), 1.0], decimal.Decimal(1.6), 0.1]
+        ))
+        df['a'] = df['a'].apply(to_numeric)
+        expected = pd.DataFrame(dict(
+            a=[[3.14, 1.0], 1.6, 0.1],
+        ))
+        tm.assert_frame_equal(df, expected)
+
+        df = pd.DataFrame(dict(
+            a=[np.array([decimal.Decimal(3.14), 1.0]), 0.1]
+        ))
+        df['a'] = df['a'].apply(to_numeric)
+        expected = pd.DataFrame(dict(
+            a=[[3.14, 1.0], 0.1],
+        ))
+        tm.assert_frame_equal(df, expected)
+
+    def test_all_nan(self):
+        s = pd.Series(['a', 'b', 'c'])
+        res = to_numeric(s, errors='coerce')
+        expected = pd.Series([np.nan, np.nan, np.nan])
+        tm.assert_series_equal(res, expected)
+
+    @pytest.mark.parametrize("errors", [None, "ignore", "raise", "coerce"])
+    def test_type_check(self, errors):
+        # see gh-11776
+        df = pd.DataFrame({"a": [1, -3.14, 7], "b": ["4", "5", "6"]})
+        kwargs = dict(errors=errors) if errors is not None else dict()
+        error_ctx = pytest.raises(TypeError, match="1-d array")
+
+        with error_ctx:
+            to_numeric(df, **kwargs)
+
+    def test_scalar(self):
+        assert pd.to_numeric(1) == 1
+        assert pd.to_numeric(1.1) == 1.1
+
+        assert pd.to_numeric('1') == 1
+        assert pd.to_numeric('1.1') == 1.1
+
+        with pytest.raises(ValueError):
+            to_numeric('XX', errors='raise')
+
+        assert to_numeric('XX', errors='ignore') == 'XX'
+        assert np.isnan(to_numeric('XX', errors='coerce'))
+
+    def test_numeric_dtypes(self):
+        idx = pd.Index([1, 2, 3], name='xxx')
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, idx)
+
+        res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        tm.assert_series_equal(res, pd.Series(idx, name='xxx'))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, idx.values)
+
+        idx = pd.Index([1., np.nan, 3., np.nan], name='xxx')
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, idx)
+
+        res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        tm.assert_series_equal(res, pd.Series(idx, name='xxx'))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, idx.values)
+
+    def test_str(self):
+        idx = pd.Index(['1', '2', '3'], name='xxx')
+        exp = np.array([1, 2, 3], dtype='int64')
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, pd.Index(exp, name='xxx'))
+
+        res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        tm.assert_series_equal(res, pd.Series(exp, name='xxx'))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, exp)
+
+        idx = pd.Index(['1.5', '2.7', '3.4'], name='xxx')
+        exp = np.array([1.5, 2.7, 3.4])
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, pd.Index(exp, name='xxx'))
+
+        res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        tm.assert_series_equal(res, pd.Series(exp, name='xxx'))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_datetime_like(self, tz_naive_fixture):
+        idx = pd.date_range("20130101", periods=3,
+                            tz=tz_naive_fixture, name="xxx")
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, pd.Index(idx.asi8, name="xxx"))
+
+        res = pd.to_numeric(pd.Series(idx, name="xxx"))
+        tm.assert_series_equal(res, pd.Series(idx.asi8, name="xxx"))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, idx.asi8)
+
+    def test_timedelta(self):
+        idx = pd.timedelta_range('1 days', periods=3, freq='D', name='xxx')
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, pd.Index(idx.asi8, name='xxx'))
+
+        res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        tm.assert_series_equal(res, pd.Series(idx.asi8, name='xxx'))
+
+        res = pd.to_numeric(idx.values)
+        tm.assert_numpy_array_equal(res, idx.asi8)
+
+    def test_period(self):
+        idx = pd.period_range('2011-01', periods=3, freq='M', name='xxx')
+        res = pd.to_numeric(idx)
+        tm.assert_index_equal(res, pd.Index(idx.asi8, name='xxx'))
+
+        # TODO: enable when we can support native PeriodDtype
+        # res = pd.to_numeric(pd.Series(idx, name='xxx'))
+        # tm.assert_series_equal(res, pd.Series(idx.asi8, name='xxx'))
+
+    def test_non_hashable(self):
+        # Test for Bug #13324
+        s = pd.Series([[10.0, 2], 1.0, 'apple'])
+        res = pd.to_numeric(s, errors='coerce')
+        tm.assert_series_equal(res, pd.Series([np.nan, 1.0, np.nan]))
+
+        res = pd.to_numeric(s, errors='ignore')
+        tm.assert_series_equal(res, pd.Series([[10.0, 2], 1.0, 'apple']))
+
+        with pytest.raises(TypeError, match="Invalid object type"):
+            pd.to_numeric(s)
+
+    @pytest.mark.parametrize("data", [
+        ["1", 2, 3],
+        [1, 2, 3],
+        np.array(["1970-01-02", "1970-01-03",
+                  "1970-01-04"], dtype="datetime64[D]")
+    ])
+    def test_downcast_basic(self, data):
+        # see gh-13352
+        invalid_downcast = "unsigned-integer"
+        msg = "invalid downcasting method provided"
+
+        with pytest.raises(ValueError, match=msg):
+            pd.to_numeric(data, downcast=invalid_downcast)
+
+        expected = np.array([1, 2, 3], dtype=np.int64)
+
+        # Basic function tests.
+        res = pd.to_numeric(data)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = pd.to_numeric(data, downcast=None)
+        tm.assert_numpy_array_equal(res, expected)
+
+        # Basic dtype support.
+        smallest_uint_dtype = np.dtype(np.typecodes["UnsignedInteger"][0])
+
+        # Support below np.float32 is rare and far between.
+        float_32_char = np.dtype(np.float32).char
+        smallest_float_dtype = float_32_char
+
+        expected = np.array([1, 2, 3], dtype=smallest_uint_dtype)
+        res = pd.to_numeric(data, downcast="unsigned")
+        tm.assert_numpy_array_equal(res, expected)
+
+        expected = np.array([1, 2, 3], dtype=smallest_float_dtype)
+        res = pd.to_numeric(data, downcast="float")
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("signed_downcast", ["integer", "signed"])
+    @pytest.mark.parametrize("data", [
+        ["1", 2, 3],
+        [1, 2, 3],
+        np.array(["1970-01-02", "1970-01-03",
+                  "1970-01-04"], dtype="datetime64[D]")
+    ])
+    def test_signed_downcast(self, data, signed_downcast):
+        # see gh-13352
+        smallest_int_dtype = np.dtype(np.typecodes["Integer"][0])
+        expected = np.array([1, 2, 3], dtype=smallest_int_dtype)
+
+        res = pd.to_numeric(data, downcast=signed_downcast)
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_ignore_downcast_invalid_data(self):
+        # If we can't successfully cast the given
+        # data to a numeric dtype, do not bother
+        # with the downcast parameter.
+        data = ["foo", 2, 3]
+        expected = np.array(data, dtype=object)
+
+        res = pd.to_numeric(data, errors="ignore",
+                            downcast="unsigned")
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_ignore_downcast_neg_to_unsigned(self):
+        # Cannot cast to an unsigned integer
+        # because we have a negative number.
+        data = ["-1", 2, 3]
+        expected = np.array([-1, 2, 3], dtype=np.int64)
+
+        res = pd.to_numeric(data, downcast="unsigned")
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("downcast", ["integer", "signed", "unsigned"])
+    @pytest.mark.parametrize("data,expected", [
+        (["1.1", 2, 3],
+         np.array([1.1, 2, 3], dtype=np.float64)),
+        ([10000.0, 20000, 3000, 40000.36, 50000, 50000.00],
+         np.array([10000.0, 20000, 3000,
+                   40000.36, 50000, 50000.00], dtype=np.float64))
+    ])
+    def test_ignore_downcast_cannot_convert_float(
+            self, data, expected, downcast):
+        # Cannot cast to an integer (signed or unsigned)
+        # because we have a float number.
+        res = pd.to_numeric(data, downcast=downcast)
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("downcast,expected_dtype", [
+        ("integer", np.int16),
+        ("signed", np.int16),
+        ("unsigned", np.uint16)
+    ])
+    def test_downcast_not8bit(self, downcast, expected_dtype):
+        # the smallest integer dtype need not be np.(u)int8
+        data = ["256", 257, 258]
+
+        expected = np.array([256, 257, 258], dtype=expected_dtype)
+        res = pd.to_numeric(data, downcast=downcast)
+        tm.assert_numpy_array_equal(res, expected)
+
+    @pytest.mark.parametrize("dtype,downcast,min_max", [
+        ("int8", "integer", [iinfo(np.int8).min,
+                             iinfo(np.int8).max]),
+        ("int16", "integer", [iinfo(np.int16).min,
+                              iinfo(np.int16).max]),
+        ('int32', "integer", [iinfo(np.int32).min,
+                              iinfo(np.int32).max]),
+        ('int64', "integer", [iinfo(np.int64).min,
+                              iinfo(np.int64).max]),
+        ('uint8', "unsigned", [iinfo(np.uint8).min,
+                               iinfo(np.uint8).max]),
+        ('uint16', "unsigned", [iinfo(np.uint16).min,
+                                iinfo(np.uint16).max]),
+        ('uint32', "unsigned", [iinfo(np.uint32).min,
+                                iinfo(np.uint32).max]),
+        ('uint64', "unsigned", [iinfo(np.uint64).min,
+                                iinfo(np.uint64).max]),
+        ('int16', "integer", [iinfo(np.int8).min,
+                              iinfo(np.int8).max + 1]),
+        ('int32', "integer", [iinfo(np.int16).min,
+                              iinfo(np.int16).max + 1]),
+        ('int64', "integer", [iinfo(np.int32).min,
+                              iinfo(np.int32).max + 1]),
+        ('int16', "integer", [iinfo(np.int8).min - 1,
+                              iinfo(np.int16).max]),
+        ('int32', "integer", [iinfo(np.int16).min - 1,
+                              iinfo(np.int32).max]),
+        ('int64', "integer", [iinfo(np.int32).min - 1,
+                              iinfo(np.int64).max]),
+        ('uint16', "unsigned", [iinfo(np.uint8).min,
+                                iinfo(np.uint8).max + 1]),
+        ('uint32', "unsigned", [iinfo(np.uint16).min,
+                                iinfo(np.uint16).max + 1]),
+        ('uint64', "unsigned", [iinfo(np.uint32).min,
+                                iinfo(np.uint32).max + 1])
+    ])
+    def test_downcast_limits(self, dtype, downcast, min_max):
+        # see gh-14404: test the limits of each downcast.
+        series = pd.to_numeric(pd.Series(min_max), downcast=downcast)
+        assert series.dtype == dtype
+
+    def test_coerce_uint64_conflict(self):
+        # see gh-17007 and gh-17125
+        #
+        # Still returns float despite the uint64-nan conflict,
+        # which would normally force the casting to object.
+        df = pd.DataFrame({"a": [200, 300, "", "NaN", 30000000000000000000]})
+        expected = pd.Series([200, 300, np.nan, np.nan,
+                              30000000000000000000], dtype=float, name="a")
+        result = to_numeric(df["a"], errors="coerce")
+        tm.assert_series_equal(result, expected)
+
+        s = pd.Series(["12345678901234567890", "1234567890", "ITEM"])
+        expected = pd.Series([12345678901234567890,
+                              1234567890, np.nan], dtype=float)
+        result = to_numeric(s, errors="coerce")
+        tm.assert_series_equal(result, expected)
+
+        # For completeness, check against "ignore" and "raise"
+        result = to_numeric(s, errors="ignore")
+        tm.assert_series_equal(result, s)
+
+        msg = "Unable to parse string"
+        with pytest.raises(ValueError, match=msg):
+            to_numeric(s, errors="raise")

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tseries/test_frequencies.py

@@ -0,0 +1,793 @@
+from datetime import datetime, timedelta
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import frequencies as libfrequencies, resolution
+from pandas._libs.tslibs.ccalendar import MONTHS
+from pandas._libs.tslibs.frequencies import (
+    INVALID_FREQ_ERR_MSG, FreqGroup, _period_code_map, get_freq, get_freq_code)
+import pandas.compat as compat
+from pandas.compat import is_platform_windows, range
+
+from pandas import (
+    DatetimeIndex, Index, Series, Timedelta, Timestamp, date_range,
+    period_range)
+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
+
+
+class TestToOffset(object):
+
+    def test_to_offset_multiple(self):
+        freqstr = '2h30min'
+        freqstr2 = '2h 30min'
+
+        result = frequencies.to_offset(freqstr)
+        assert (result == frequencies.to_offset(freqstr2))
+        expected = offsets.Minute(150)
+        assert (result == expected)
+
+        freqstr = '2h30min15s'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Second(150 * 60 + 15)
+        assert (result == expected)
+
+        freqstr = '2h 60min'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Hour(3)
+        assert (result == expected)
+
+        freqstr = '2h 20.5min'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Second(8430)
+        assert (result == expected)
+
+        freqstr = '1.5min'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Second(90)
+        assert (result == expected)
+
+        freqstr = '0.5S'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Milli(500)
+        assert (result == expected)
+
+        freqstr = '15l500u'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Micro(15500)
+        assert (result == expected)
+
+        freqstr = '10s75L'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Milli(10075)
+        assert (result == expected)
+
+        freqstr = '1s0.25ms'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Micro(1000250)
+        assert (result == expected)
+
+        freqstr = '1s0.25L'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Micro(1000250)
+        assert (result == expected)
+
+        freqstr = '2800N'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Nano(2800)
+        assert (result == expected)
+
+        freqstr = '2SM'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.SemiMonthEnd(2)
+        assert (result == expected)
+
+        freqstr = '2SM-16'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.SemiMonthEnd(2, day_of_month=16)
+        assert (result == expected)
+
+        freqstr = '2SMS-14'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.SemiMonthBegin(2, day_of_month=14)
+        assert (result == expected)
+
+        freqstr = '2SMS-15'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.SemiMonthBegin(2)
+        assert (result == expected)
+
+        # malformed
+        with pytest.raises(ValueError, match='Invalid frequency: 2h20m'):
+            frequencies.to_offset('2h20m')
+
+    def test_to_offset_negative(self):
+        freqstr = '-1S'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == -1)
+
+        freqstr = '-5min10s'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == -310)
+
+        freqstr = '-2SM'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == -2)
+
+        freqstr = '-1SMS'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == -1)
+
+    def test_to_offset_invalid(self):
+        # GH 13930
+        with pytest.raises(ValueError, match='Invalid frequency: U1'):
+            frequencies.to_offset('U1')
+        with pytest.raises(ValueError, match='Invalid frequency: -U'):
+            frequencies.to_offset('-U')
+        with pytest.raises(ValueError, match='Invalid frequency: 3U1'):
+            frequencies.to_offset('3U1')
+        with pytest.raises(ValueError, match='Invalid frequency: -2-3U'):
+            frequencies.to_offset('-2-3U')
+        with pytest.raises(ValueError, match='Invalid frequency: -2D:3H'):
+            frequencies.to_offset('-2D:3H')
+        with pytest.raises(ValueError, match='Invalid frequency: 1.5.0S'):
+            frequencies.to_offset('1.5.0S')
+
+        # split offsets with spaces are valid
+        assert frequencies.to_offset('2D 3H') == offsets.Hour(51)
+        assert frequencies.to_offset('2 D3 H') == offsets.Hour(51)
+        assert frequencies.to_offset('2 D 3 H') == offsets.Hour(51)
+        assert frequencies.to_offset('  2 D 3 H  ') == offsets.Hour(51)
+        assert frequencies.to_offset('   H    ') == offsets.Hour()
+        assert frequencies.to_offset(' 3  H    ') == offsets.Hour(3)
+
+        # special cases
+        assert frequencies.to_offset('2SMS-15') == offsets.SemiMonthBegin(2)
+        with pytest.raises(ValueError, match='Invalid frequency: 2SMS-15-15'):
+            frequencies.to_offset('2SMS-15-15')
+        with pytest.raises(ValueError, match='Invalid frequency: 2SMS-15D'):
+            frequencies.to_offset('2SMS-15D')
+
+    def test_to_offset_leading_zero(self):
+        freqstr = '00H 00T 01S'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == 1)
+
+        freqstr = '-00H 03T 14S'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == -194)
+
+    def test_to_offset_leading_plus(self):
+        freqstr = '+1d'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == 1)
+
+        freqstr = '+2h30min'
+        result = frequencies.to_offset(freqstr)
+        assert (result.n == 150)
+
+        for bad_freq in ['+-1d', '-+1h', '+1', '-7', '+d', '-m']:
+            with pytest.raises(ValueError, match='Invalid frequency:'):
+                frequencies.to_offset(bad_freq)
+
+    def test_to_offset_pd_timedelta(self):
+        # Tests for #9064
+        td = Timedelta(days=1, seconds=1)
+        result = frequencies.to_offset(td)
+        expected = offsets.Second(86401)
+        assert (expected == result)
+
+        td = Timedelta(days=-1, seconds=1)
+        result = frequencies.to_offset(td)
+        expected = offsets.Second(-86399)
+        assert (expected == result)
+
+        td = Timedelta(hours=1, minutes=10)
+        result = frequencies.to_offset(td)
+        expected = offsets.Minute(70)
+        assert (expected == result)
+
+        td = Timedelta(hours=1, minutes=-10)
+        result = frequencies.to_offset(td)
+        expected = offsets.Minute(50)
+        assert (expected == result)
+
+        td = Timedelta(weeks=1)
+        result = frequencies.to_offset(td)
+        expected = offsets.Day(7)
+        assert (expected == result)
+
+        td1 = Timedelta(hours=1)
+        result1 = frequencies.to_offset(td1)
+        result2 = frequencies.to_offset('60min')
+        assert (result1 == result2)
+
+        td = Timedelta(microseconds=1)
+        result = frequencies.to_offset(td)
+        expected = offsets.Micro(1)
+        assert (expected == result)
+
+        td = Timedelta(microseconds=0)
+        pytest.raises(ValueError, lambda: frequencies.to_offset(td))
+
+    def test_anchored_shortcuts(self):
+        result = frequencies.to_offset('W')
+        expected = frequencies.to_offset('W-SUN')
+        assert (result == expected)
+
+        result1 = frequencies.to_offset('Q')
+        result2 = frequencies.to_offset('Q-DEC')
+        expected = offsets.QuarterEnd(startingMonth=12)
+        assert (result1 == expected)
+        assert (result2 == expected)
+
+        result1 = frequencies.to_offset('Q-MAY')
+        expected = offsets.QuarterEnd(startingMonth=5)
+        assert (result1 == expected)
+
+        result1 = frequencies.to_offset('SM')
+        result2 = frequencies.to_offset('SM-15')
+        expected = offsets.SemiMonthEnd(day_of_month=15)
+        assert (result1 == expected)
+        assert (result2 == expected)
+
+        result = frequencies.to_offset('SM-1')
+        expected = offsets.SemiMonthEnd(day_of_month=1)
+        assert (result == expected)
+
+        result = frequencies.to_offset('SM-27')
+        expected = offsets.SemiMonthEnd(day_of_month=27)
+        assert (result == expected)
+
+        result = frequencies.to_offset('SMS-2')
+        expected = offsets.SemiMonthBegin(day_of_month=2)
+        assert (result == expected)
+
+        result = frequencies.to_offset('SMS-27')
+        expected = offsets.SemiMonthBegin(day_of_month=27)
+        assert (result == expected)
+
+        # ensure invalid cases fail as expected
+        invalid_anchors = ['SM-0', 'SM-28', 'SM-29',
+                           'SM-FOO', 'BSM', 'SM--1',
+                           'SMS-1', 'SMS-28', 'SMS-30',
+                           'SMS-BAR', 'SMS-BYR' 'BSMS',
+                           'SMS--2']
+        for invalid_anchor in invalid_anchors:
+            with pytest.raises(ValueError, match='Invalid frequency: '):
+                frequencies.to_offset(invalid_anchor)
+
+
+def test_ms_vs_MS():
+    left = frequencies.get_offset('ms')
+    right = frequencies.get_offset('MS')
+    assert left == offsets.Milli()
+    assert right == offsets.MonthBegin()
+
+
+def test_rule_aliases():
+    rule = frequencies.to_offset('10us')
+    assert rule == offsets.Micro(10)
+
+
+class TestFrequencyCode(object):
+
+    def test_freq_code(self):
+        assert get_freq('A') == 1000
+        assert get_freq('3A') == 1000
+        assert get_freq('-1A') == 1000
+
+        assert get_freq('Y') == 1000
+        assert get_freq('3Y') == 1000
+        assert get_freq('-1Y') == 1000
+
+        assert get_freq('W') == 4000
+        assert get_freq('W-MON') == 4001
+        assert get_freq('W-FRI') == 4005
+
+        for freqstr, code in compat.iteritems(_period_code_map):
+            result = get_freq(freqstr)
+            assert result == code
+
+            result = resolution.get_freq_group(freqstr)
+            assert result == code // 1000 * 1000
+
+            result = resolution.get_freq_group(code)
+            assert result == code // 1000 * 1000
+
+    def test_freq_group(self):
+        assert resolution.get_freq_group('A') == 1000
+        assert resolution.get_freq_group('3A') == 1000
+        assert resolution.get_freq_group('-1A') == 1000
+        assert resolution.get_freq_group('A-JAN') == 1000
+        assert resolution.get_freq_group('A-MAY') == 1000
+
+        assert resolution.get_freq_group('Y') == 1000
+        assert resolution.get_freq_group('3Y') == 1000
+        assert resolution.get_freq_group('-1Y') == 1000
+        assert resolution.get_freq_group('Y-JAN') == 1000
+        assert resolution.get_freq_group('Y-MAY') == 1000
+
+        assert resolution.get_freq_group(offsets.YearEnd()) == 1000
+        assert resolution.get_freq_group(offsets.YearEnd(month=1)) == 1000
+        assert resolution.get_freq_group(offsets.YearEnd(month=5)) == 1000
+
+        assert resolution.get_freq_group('W') == 4000
+        assert resolution.get_freq_group('W-MON') == 4000
+        assert resolution.get_freq_group('W-FRI') == 4000
+        assert resolution.get_freq_group(offsets.Week()) == 4000
+        assert resolution.get_freq_group(offsets.Week(weekday=1)) == 4000
+        assert resolution.get_freq_group(offsets.Week(weekday=5)) == 4000
+
+    def test_get_to_timestamp_base(self):
+        tsb = libfrequencies.get_to_timestamp_base
+
+        assert (tsb(get_freq_code('D')[0]) ==
+                get_freq_code('D')[0])
+        assert (tsb(get_freq_code('W')[0]) ==
+                get_freq_code('D')[0])
+        assert (tsb(get_freq_code('M')[0]) ==
+                get_freq_code('D')[0])
+
+        assert (tsb(get_freq_code('S')[0]) ==
+                get_freq_code('S')[0])
+        assert (tsb(get_freq_code('T')[0]) ==
+                get_freq_code('S')[0])
+        assert (tsb(get_freq_code('H')[0]) ==
+                get_freq_code('S')[0])
+
+    def test_freq_to_reso(self):
+        Reso = resolution.Resolution
+
+        assert Reso.get_str_from_freq('A') == 'year'
+        assert Reso.get_str_from_freq('Q') == 'quarter'
+        assert Reso.get_str_from_freq('M') == 'month'
+        assert Reso.get_str_from_freq('D') == 'day'
+        assert Reso.get_str_from_freq('H') == 'hour'
+        assert Reso.get_str_from_freq('T') == 'minute'
+        assert Reso.get_str_from_freq('S') == 'second'
+        assert Reso.get_str_from_freq('L') == 'millisecond'
+        assert Reso.get_str_from_freq('U') == 'microsecond'
+        assert Reso.get_str_from_freq('N') == 'nanosecond'
+
+        for freq in ['A', 'Q', 'M', 'D', 'H', 'T', 'S', 'L', 'U', 'N']:
+            # check roundtrip
+            result = Reso.get_freq(Reso.get_str_from_freq(freq))
+            assert freq == result
+
+        for freq in ['D', 'H', 'T', 'S', 'L', 'U']:
+            result = Reso.get_freq(Reso.get_str(Reso.get_reso_from_freq(freq)))
+            assert freq == result
+
+    def test_resolution_bumping(self):
+        # see gh-14378
+        Reso = resolution.Resolution
+
+        assert Reso.get_stride_from_decimal(1.5, 'T') == (90, 'S')
+        assert Reso.get_stride_from_decimal(62.4, 'T') == (3744, 'S')
+        assert Reso.get_stride_from_decimal(1.04, 'H') == (3744, 'S')
+        assert Reso.get_stride_from_decimal(1, 'D') == (1, 'D')
+        assert (Reso.get_stride_from_decimal(0.342931, 'H') ==
+                (1234551600, 'U'))
+        assert Reso.get_stride_from_decimal(1.2345, 'D') == (106660800, 'L')
+
+        with pytest.raises(ValueError):
+            Reso.get_stride_from_decimal(0.5, 'N')
+
+        # too much precision in the input can prevent
+        with pytest.raises(ValueError):
+            Reso.get_stride_from_decimal(0.3429324798798269273987982, 'H')
+
+    def test_get_freq_code(self):
+        # frequency str
+        assert (get_freq_code('A') ==
+                (get_freq('A'), 1))
+        assert (get_freq_code('3D') ==
+                (get_freq('D'), 3))
+        assert (get_freq_code('-2M') ==
+                (get_freq('M'), -2))
+
+        # tuple
+        assert (get_freq_code(('D', 1)) ==
+                (get_freq('D'), 1))
+        assert (get_freq_code(('A', 3)) ==
+                (get_freq('A'), 3))
+        assert (get_freq_code(('M', -2)) ==
+                (get_freq('M'), -2))
+
+        # numeric tuple
+        assert get_freq_code((1000, 1)) == (1000, 1)
+
+        # offsets
+        assert (get_freq_code(offsets.Day()) ==
+                (get_freq('D'), 1))
+        assert (get_freq_code(offsets.Day(3)) ==
+                (get_freq('D'), 3))
+        assert (get_freq_code(offsets.Day(-2)) ==
+                (get_freq('D'), -2))
+
+        assert (get_freq_code(offsets.MonthEnd()) ==
+                (get_freq('M'), 1))
+        assert (get_freq_code(offsets.MonthEnd(3)) ==
+                (get_freq('M'), 3))
+        assert (get_freq_code(offsets.MonthEnd(-2)) ==
+                (get_freq('M'), -2))
+
+        assert (get_freq_code(offsets.Week()) ==
+                (get_freq('W'), 1))
+        assert (get_freq_code(offsets.Week(3)) ==
+                (get_freq('W'), 3))
+        assert (get_freq_code(offsets.Week(-2)) ==
+                (get_freq('W'), -2))
+
+        # Monday is weekday=0
+        assert (get_freq_code(offsets.Week(weekday=1)) ==
+                (get_freq('W-TUE'), 1))
+        assert (get_freq_code(offsets.Week(3, weekday=0)) ==
+                (get_freq('W-MON'), 3))
+        assert (get_freq_code(offsets.Week(-2, weekday=4)) ==
+                (get_freq('W-FRI'), -2))
+
+    def test_frequency_misc(self):
+        assert (resolution.get_freq_group('T') ==
+                FreqGroup.FR_MIN)
+
+        code, stride = get_freq_code(offsets.Hour())
+        assert code == FreqGroup.FR_HR
+
+        code, stride = get_freq_code((5, 'T'))
+        assert code == FreqGroup.FR_MIN
+        assert stride == 5
+
+        offset = offsets.Hour()
+        result = frequencies.to_offset(offset)
+        assert result == offset
+
+        result = frequencies.to_offset((5, 'T'))
+        expected = offsets.Minute(5)
+        assert result == expected
+
+        with pytest.raises(ValueError, match='Invalid frequency'):
+            get_freq_code((5, 'baz'))
+
+        with pytest.raises(ValueError, match='Invalid frequency'):
+            frequencies.to_offset('100foo')
+
+        with pytest.raises(ValueError, match='Could not evaluate'):
+            frequencies.to_offset(('', ''))
+
+
+_dti = DatetimeIndex
+
+
+class TestFrequencyInference(object):
+
+    def test_raise_if_period_index(self):
+        index = period_range(start="1/1/1990", periods=20, freq="M")
+        pytest.raises(TypeError, frequencies.infer_freq, index)
+
+    def test_raise_if_too_few(self):
+        index = _dti(['12/31/1998', '1/3/1999'])
+        pytest.raises(ValueError, frequencies.infer_freq, index)
+
+    def test_business_daily(self):
+        index = _dti(['01/01/1999', '1/4/1999', '1/5/1999'])
+        assert frequencies.infer_freq(index) == 'B'
+
+    def test_business_daily_look_alike(self):
+        # GH 16624, do not infer 'B' when 'weekend' (2-day gap) in wrong place
+        index = _dti(['12/31/1998', '1/3/1999', '1/4/1999'])
+        assert frequencies.infer_freq(index) is None
+
+    def test_day(self):
+        self._check_tick(timedelta(1), 'D')
+
+    def test_day_corner(self):
+        index = _dti(['1/1/2000', '1/2/2000', '1/3/2000'])
+        assert frequencies.infer_freq(index) == 'D'
+
+    def test_non_datetimeindex(self):
+        dates = to_datetime(['1/1/2000', '1/2/2000', '1/3/2000'])
+        assert frequencies.infer_freq(dates) == 'D'
+
+    def test_hour(self):
+        self._check_tick(timedelta(hours=1), 'H')
+
+    def test_minute(self):
+        self._check_tick(timedelta(minutes=1), 'T')
+
+    def test_second(self):
+        self._check_tick(timedelta(seconds=1), 'S')
+
+    def test_millisecond(self):
+        self._check_tick(timedelta(microseconds=1000), 'L')
+
+    def test_microsecond(self):
+        self._check_tick(timedelta(microseconds=1), 'U')
+
+    def test_nanosecond(self):
+        self._check_tick(np.timedelta64(1, 'ns'), 'N')
+
+    def _check_tick(self, base_delta, code):
+        b = Timestamp(datetime.now())
+        for i in range(1, 5):
+            inc = base_delta * i
+            index = _dti([b + inc * j for j in range(3)])
+            if i > 1:
+                exp_freq = '%d%s' % (i, code)
+            else:
+                exp_freq = code
+            assert frequencies.infer_freq(index) == exp_freq
+
+        index = _dti([b + base_delta * 7] + [b + base_delta * j for j in range(
+            3)])
+        assert frequencies.infer_freq(index) is None
+
+        index = _dti([b + base_delta * j for j in range(3)] + [b + base_delta *
+                                                               7])
+
+        assert frequencies.infer_freq(index) is None
+
+    def test_weekly(self):
+        days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
+
+        for day in days:
+            self._check_generated_range('1/1/2000', 'W-%s' % day)
+
+    def test_week_of_month(self):
+        days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
+
+        for day in days:
+            for i in range(1, 5):
+                self._check_generated_range('1/1/2000', 'WOM-%d%s' % (i, day))
+
+    def test_fifth_week_of_month(self):
+        # Only supports freq up to WOM-4. See #9425
+        func = lambda: date_range('2014-01-01', freq='WOM-5MON')
+        pytest.raises(ValueError, func)
+
+    def test_fifth_week_of_month_infer(self):
+        # Only attempts to infer up to WOM-4. See #9425
+        index = DatetimeIndex(["2014-03-31", "2014-06-30", "2015-03-30"])
+        assert frequencies.infer_freq(index) is None
+
+    def test_week_of_month_fake(self):
+        # All of these dates are on same day of week and are 4 or 5 weeks apart
+        index = DatetimeIndex(["2013-08-27", "2013-10-01", "2013-10-29",
+                               "2013-11-26"])
+        assert frequencies.infer_freq(index) != 'WOM-4TUE'
+
+    def test_monthly(self):
+        self._check_generated_range('1/1/2000', 'M')
+
+    def test_monthly_ambiguous(self):
+        rng = _dti(['1/31/2000', '2/29/2000', '3/31/2000'])
+        assert rng.inferred_freq == 'M'
+
+    def test_business_monthly(self):
+        self._check_generated_range('1/1/2000', 'BM')
+
+    def test_business_start_monthly(self):
+        self._check_generated_range('1/1/2000', 'BMS')
+
+    def test_quarterly(self):
+        for month in ['JAN', 'FEB', 'MAR']:
+            self._check_generated_range('1/1/2000', 'Q-%s' % month)
+
+    def test_annual(self):
+        for month in MONTHS:
+            self._check_generated_range('1/1/2000', 'A-%s' % month)
+
+    def test_business_annual(self):
+        for month in MONTHS:
+            self._check_generated_range('1/1/2000', 'BA-%s' % month)
+
+    def test_annual_ambiguous(self):
+        rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
+        assert rng.inferred_freq == 'A-JAN'
+
+    def _check_generated_range(self, start, freq):
+        freq = freq.upper()
+
+        gen = date_range(start, periods=7, freq=freq)
+        index = _dti(gen.values)
+        if not freq.startswith('Q-'):
+            assert frequencies.infer_freq(index) == gen.freqstr
+        else:
+            inf_freq = frequencies.infer_freq(index)
+            is_dec_range = inf_freq == 'Q-DEC' and gen.freqstr in (
+                'Q', 'Q-DEC', 'Q-SEP', 'Q-JUN', 'Q-MAR')
+            is_nov_range = inf_freq == 'Q-NOV' and gen.freqstr in (
+                'Q-NOV', 'Q-AUG', 'Q-MAY', 'Q-FEB')
+            is_oct_range = inf_freq == 'Q-OCT' and gen.freqstr in (
+                'Q-OCT', 'Q-JUL', 'Q-APR', 'Q-JAN')
+            assert is_dec_range or is_nov_range or is_oct_range
+
+        gen = date_range(start, periods=5, freq=freq)
+        index = _dti(gen.values)
+
+        if not freq.startswith('Q-'):
+            assert frequencies.infer_freq(index) == gen.freqstr
+        else:
+            inf_freq = frequencies.infer_freq(index)
+            is_dec_range = inf_freq == 'Q-DEC' and gen.freqstr in (
+                'Q', 'Q-DEC', 'Q-SEP', 'Q-JUN', 'Q-MAR')
+            is_nov_range = inf_freq == 'Q-NOV' and gen.freqstr in (
+                'Q-NOV', 'Q-AUG', 'Q-MAY', 'Q-FEB')
+            is_oct_range = inf_freq == 'Q-OCT' and gen.freqstr in (
+                'Q-OCT', 'Q-JUL', 'Q-APR', 'Q-JAN')
+
+            assert is_dec_range or is_nov_range or is_oct_range
+
+    def test_infer_freq(self):
+        rng = period_range('1959Q2', '2009Q3', freq='Q')
+        rng = Index(rng.to_timestamp('D', how='e').astype(object))
+        assert rng.inferred_freq == 'Q-DEC'
+
+        rng = period_range('1959Q2', '2009Q3', freq='Q-NOV')
+        rng = Index(rng.to_timestamp('D', how='e').astype(object))
+        assert rng.inferred_freq == 'Q-NOV'
+
+        rng = period_range('1959Q2', '2009Q3', freq='Q-OCT')
+        rng = Index(rng.to_timestamp('D', how='e').astype(object))
+        assert rng.inferred_freq == 'Q-OCT'
+
+    def test_infer_freq_tz(self):
+
+        freqs = {'AS-JAN':
+                 ['2009-01-01', '2010-01-01', '2011-01-01', '2012-01-01'],
+                 'Q-OCT':
+                 ['2009-01-31', '2009-04-30', '2009-07-31', '2009-10-31'],
+                 'M': ['2010-11-30', '2010-12-31', '2011-01-31', '2011-02-28'],
+                 'W-SAT':
+                 ['2010-12-25', '2011-01-01', '2011-01-08', '2011-01-15'],
+                 'D': ['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04'],
+                 'H': ['2011-12-31 22:00', '2011-12-31 23:00',
+                       '2012-01-01 00:00', '2012-01-01 01:00']}
+
+        # GH 7310
+        for tz in [None, 'Australia/Sydney', 'Asia/Tokyo', 'Europe/Paris',
+                   'US/Pacific', 'US/Eastern']:
+            for expected, dates in compat.iteritems(freqs):
+                idx = DatetimeIndex(dates, tz=tz)
+                assert idx.inferred_freq == expected
+
+    def test_infer_freq_tz_transition(self):
+        # Tests for #8772
+        date_pairs = [['2013-11-02', '2013-11-5'],  # Fall DST
+                      ['2014-03-08', '2014-03-11'],  # Spring DST
+                      ['2014-01-01', '2014-01-03']]  # Regular Time
+        freqs = ['3H', '10T', '3601S', '3600001L', '3600000001U',
+                 '3600000000001N']
+
+        for tz in [None, 'Australia/Sydney', 'Asia/Tokyo', 'Europe/Paris',
+                   'US/Pacific', 'US/Eastern']:
+            for date_pair in date_pairs:
+                for freq in freqs:
+                    idx = date_range(date_pair[0], date_pair[
+                        1], freq=freq, tz=tz)
+                    assert idx.inferred_freq == freq
+
+        index = date_range("2013-11-03", periods=5,
+                           freq="3H").tz_localize("America/Chicago")
+        assert index.inferred_freq is None
+
+    def test_infer_freq_businesshour(self):
+        # GH 7905
+        idx = DatetimeIndex(
+            ['2014-07-01 09:00', '2014-07-01 10:00', '2014-07-01 11:00',
+             '2014-07-01 12:00', '2014-07-01 13:00', '2014-07-01 14:00'])
+        # hourly freq in a day must result in 'H'
+        assert idx.inferred_freq == 'H'
+
+        idx = DatetimeIndex(
+            ['2014-07-01 09:00', '2014-07-01 10:00', '2014-07-01 11:00',
+             '2014-07-01 12:00', '2014-07-01 13:00', '2014-07-01 14:00',
+             '2014-07-01 15:00', '2014-07-01 16:00', '2014-07-02 09:00',
+             '2014-07-02 10:00', '2014-07-02 11:00'])
+        assert idx.inferred_freq == 'BH'
+
+        idx = DatetimeIndex(
+            ['2014-07-04 09:00', '2014-07-04 10:00', '2014-07-04 11:00',
+             '2014-07-04 12:00', '2014-07-04 13:00', '2014-07-04 14:00',
+             '2014-07-04 15:00', '2014-07-04 16:00', '2014-07-07 09:00',
+             '2014-07-07 10:00', '2014-07-07 11:00'])
+        assert idx.inferred_freq == 'BH'
+
+        idx = DatetimeIndex(
+            ['2014-07-04 09:00', '2014-07-04 10:00', '2014-07-04 11:00',
+             '2014-07-04 12:00', '2014-07-04 13:00', '2014-07-04 14:00',
+             '2014-07-04 15:00', '2014-07-04 16:00', '2014-07-07 09:00',
+             '2014-07-07 10:00', '2014-07-07 11:00', '2014-07-07 12:00',
+             '2014-07-07 13:00', '2014-07-07 14:00', '2014-07-07 15:00',
+             '2014-07-07 16:00', '2014-07-08 09:00', '2014-07-08 10:00',
+             '2014-07-08 11:00', '2014-07-08 12:00', '2014-07-08 13:00',
+             '2014-07-08 14:00', '2014-07-08 15:00', '2014-07-08 16:00'])
+        assert idx.inferred_freq == 'BH'
+
+    def test_not_monotonic(self):
+        rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
+        rng = rng[::-1]
+        assert rng.inferred_freq == '-1A-JAN'
+
+    def test_non_datetimeindex2(self):
+        rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
+
+        vals = rng.to_pydatetime()
+
+        result = frequencies.infer_freq(vals)
+        assert result == rng.inferred_freq
+
+    def test_invalid_index_types(self):
+
+        # test all index types
+        for i in [tm.makeIntIndex(10), tm.makeFloatIndex(10),
+                  tm.makePeriodIndex(10)]:
+            pytest.raises(TypeError, lambda: frequencies.infer_freq(i))
+
+        # GH 10822
+        # odd error message on conversions to datetime for unicode
+        if not is_platform_windows():
+            for i in [tm.makeStringIndex(10), tm.makeUnicodeIndex(10)]:
+                pytest.raises(ValueError, lambda: frequencies.infer_freq(i))
+
+    def test_string_datetimelike_compat(self):
+
+        # GH 6463
+        expected = frequencies.infer_freq(['2004-01', '2004-02', '2004-03',
+                                           '2004-04'])
+        result = frequencies.infer_freq(Index(['2004-01', '2004-02', '2004-03',
+                                               '2004-04']))
+        assert result == expected
+
+    def test_series(self):
+
+        # GH6407
+        # inferring series
+
+        # invalid type of Series
+        for s in [Series(np.arange(10)), Series(np.arange(10.))]:
+            pytest.raises(TypeError, lambda: frequencies.infer_freq(s))
+
+        # a non-convertible string
+        pytest.raises(ValueError, lambda: frequencies.infer_freq(
+            Series(['foo', 'bar'])))
+
+        # cannot infer on PeriodIndex
+        for freq in [None, 'L']:
+            s = Series(period_range('2013', periods=10, freq=freq))
+            pytest.raises(TypeError, lambda: frequencies.infer_freq(s))
+
+        # DateTimeIndex
+        for freq in ['M', 'L', 'S']:
+            s = Series(date_range('20130101', periods=10, freq=freq))
+            inferred = frequencies.infer_freq(s)
+            assert inferred == freq
+
+        s = Series(date_range('20130101', '20130110'))
+        inferred = frequencies.infer_freq(s)
+        assert inferred == 'D'
+
+    def test_legacy_offset_warnings(self):
+        freqs = ['WEEKDAY', 'EOM', 'W@MON', 'W@TUE', 'W@WED', 'W@THU',
+                 'W@FRI', 'W@SAT', 'W@SUN', 'Q@JAN', 'Q@FEB', 'Q@MAR',
+                 'A@JAN', 'A@FEB', 'A@MAR', 'A@APR', 'A@MAY', 'A@JUN',
+                 'A@JUL', 'A@AUG', 'A@SEP', 'A@OCT', 'A@NOV', 'A@DEC',
+                 'Y@JAN', 'WOM@1MON', 'WOM@2MON', 'WOM@3MON',
+                 'WOM@4MON', 'WOM@1TUE', 'WOM@2TUE', 'WOM@3TUE',
+                 'WOM@4TUE', 'WOM@1WED', 'WOM@2WED', 'WOM@3WED',
+                 'WOM@4WED', 'WOM@1THU', 'WOM@2THU', 'WOM@3THU',
+                 'WOM@4THU', 'WOM@1FRI', 'WOM@2FRI', 'WOM@3FRI',
+                 'WOM@4FRI']
+
+        msg = INVALID_FREQ_ERR_MSG
+        for freq in freqs:
+            with pytest.raises(ValueError, match=msg):
+                frequencies.get_offset(freq)
+
+            with pytest.raises(ValueError, match=msg):
+                date_range('2011-01-01', periods=5, freq=freq)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tseries/test_holiday.py

@@ -0,0 +1,382 @@
+from datetime import datetime
+
+import pytest
+from pytz import utc
+
+from pandas import DatetimeIndex, compat
+import pandas.util.testing as tm
+
+from pandas.tseries.holiday import (
+    MO, SA, AbstractHolidayCalendar, DateOffset, EasterMonday, GoodFriday,
+    Holiday, HolidayCalendarFactory, Timestamp, USColumbusDay,
+    USFederalHolidayCalendar, USLaborDay, USMartinLutherKingJr, USMemorialDay,
+    USPresidentsDay, USThanksgivingDay, after_nearest_workday,
+    before_nearest_workday, get_calendar, nearest_workday, next_monday,
+    next_monday_or_tuesday, next_workday, previous_friday, previous_workday,
+    sunday_to_monday, weekend_to_monday)
+
+
+class TestCalendar(object):
+
+    def setup_method(self, method):
+        self.holiday_list = [
+            datetime(2012, 1, 2),
+            datetime(2012, 1, 16),
+            datetime(2012, 2, 20),
+            datetime(2012, 5, 28),
+            datetime(2012, 7, 4),
+            datetime(2012, 9, 3),
+            datetime(2012, 10, 8),
+            datetime(2012, 11, 12),
+            datetime(2012, 11, 22),
+            datetime(2012, 12, 25)]
+
+        self.start_date = datetime(2012, 1, 1)
+        self.end_date = datetime(2012, 12, 31)
+
+    def test_calendar(self):
+
+        calendar = USFederalHolidayCalendar()
+        holidays = calendar.holidays(self.start_date, self.end_date)
+
+        holidays_1 = calendar.holidays(
+            self.start_date.strftime('%Y-%m-%d'),
+            self.end_date.strftime('%Y-%m-%d'))
+        holidays_2 = calendar.holidays(
+            Timestamp(self.start_date),
+            Timestamp(self.end_date))
+
+        assert list(holidays.to_pydatetime()) == self.holiday_list
+        assert list(holidays_1.to_pydatetime()) == self.holiday_list
+        assert list(holidays_2.to_pydatetime()) == self.holiday_list
+
+    def test_calendar_caching(self):
+        # Test for issue #9552
+
+        class TestCalendar(AbstractHolidayCalendar):
+
+            def __init__(self, name=None, rules=None):
+                super(TestCalendar, self).__init__(name=name, rules=rules)
+
+        jan1 = TestCalendar(rules=[Holiday('jan1', year=2015, month=1, day=1)])
+        jan2 = TestCalendar(rules=[Holiday('jan2', year=2015, month=1, day=2)])
+
+        tm.assert_index_equal(jan1.holidays(), DatetimeIndex(['01-Jan-2015']))
+        tm.assert_index_equal(jan2.holidays(), DatetimeIndex(['02-Jan-2015']))
+
+    def test_calendar_observance_dates(self):
+        # Test for issue 11477
+        USFedCal = get_calendar('USFederalHolidayCalendar')
+        holidays0 = USFedCal.holidays(datetime(2015, 7, 3), datetime(
+            2015, 7, 3))  # <-- same start and end dates
+        holidays1 = USFedCal.holidays(datetime(2015, 7, 3), datetime(
+            2015, 7, 6))  # <-- different start and end dates
+        holidays2 = USFedCal.holidays(datetime(2015, 7, 3), datetime(
+            2015, 7, 3))  # <-- same start and end dates
+
+        tm.assert_index_equal(holidays0, holidays1)
+        tm.assert_index_equal(holidays0, holidays2)
+
+    def test_rule_from_name(self):
+        USFedCal = get_calendar('USFederalHolidayCalendar')
+        assert USFedCal.rule_from_name('Thanksgiving') == USThanksgivingDay
+
+
+class TestHoliday(object):
+
+    def setup_method(self, method):
+        self.start_date = datetime(2011, 1, 1)
+        self.end_date = datetime(2020, 12, 31)
+
+    def check_results(self, holiday, start, end, expected):
+        assert list(holiday.dates(start, end)) == expected
+
+        # Verify that timezone info is preserved.
+        assert (list(holiday.dates(utc.localize(Timestamp(start)),
+                                   utc.localize(Timestamp(end)))) ==
+                [utc.localize(dt) for dt in expected])
+
+    def test_usmemorialday(self):
+        self.check_results(holiday=USMemorialDay,
+                           start=self.start_date,
+                           end=self.end_date,
+                           expected=[
+                               datetime(2011, 5, 30),
+                               datetime(2012, 5, 28),
+                               datetime(2013, 5, 27),
+                               datetime(2014, 5, 26),
+                               datetime(2015, 5, 25),
+                               datetime(2016, 5, 30),
+                               datetime(2017, 5, 29),
+                               datetime(2018, 5, 28),
+                               datetime(2019, 5, 27),
+                               datetime(2020, 5, 25),
+                           ], )
+
+    def test_non_observed_holiday(self):
+
+        self.check_results(
+            Holiday('July 4th Eve', month=7, day=3),
+            start="2001-01-01",
+            end="2003-03-03",
+            expected=[
+                Timestamp('2001-07-03 00:00:00'),
+                Timestamp('2002-07-03 00:00:00')
+            ]
+        )
+
+        self.check_results(
+            Holiday('July 4th Eve', month=7, day=3, days_of_week=(0, 1, 2, 3)),
+            start="2001-01-01",
+            end="2008-03-03",
+            expected=[
+                Timestamp('2001-07-03 00:00:00'),
+                Timestamp('2002-07-03 00:00:00'),
+                Timestamp('2003-07-03 00:00:00'),
+                Timestamp('2006-07-03 00:00:00'),
+                Timestamp('2007-07-03 00:00:00'),
+            ]
+        )
+
+    def test_easter(self):
+
+        self.check_results(EasterMonday,
+                           start=self.start_date,
+                           end=self.end_date,
+                           expected=[
+                               Timestamp('2011-04-25 00:00:00'),
+                               Timestamp('2012-04-09 00:00:00'),
+                               Timestamp('2013-04-01 00:00:00'),
+                               Timestamp('2014-04-21 00:00:00'),
+                               Timestamp('2015-04-06 00:00:00'),
+                               Timestamp('2016-03-28 00:00:00'),
+                               Timestamp('2017-04-17 00:00:00'),
+                               Timestamp('2018-04-02 00:00:00'),
+                               Timestamp('2019-04-22 00:00:00'),
+                               Timestamp('2020-04-13 00:00:00'),
+                           ], )
+        self.check_results(GoodFriday,
+                           start=self.start_date,
+                           end=self.end_date,
+                           expected=[
+                               Timestamp('2011-04-22 00:00:00'),
+                               Timestamp('2012-04-06 00:00:00'),
+                               Timestamp('2013-03-29 00:00:00'),
+                               Timestamp('2014-04-18 00:00:00'),
+                               Timestamp('2015-04-03 00:00:00'),
+                               Timestamp('2016-03-25 00:00:00'),
+                               Timestamp('2017-04-14 00:00:00'),
+                               Timestamp('2018-03-30 00:00:00'),
+                               Timestamp('2019-04-19 00:00:00'),
+                               Timestamp('2020-04-10 00:00:00'),
+                           ], )
+
+    def test_usthanksgivingday(self):
+
+        self.check_results(USThanksgivingDay,
+                           start=self.start_date,
+                           end=self.end_date,
+                           expected=[
+                               datetime(2011, 11, 24),
+                               datetime(2012, 11, 22),
+                               datetime(2013, 11, 28),
+                               datetime(2014, 11, 27),
+                               datetime(2015, 11, 26),
+                               datetime(2016, 11, 24),
+                               datetime(2017, 11, 23),
+                               datetime(2018, 11, 22),
+                               datetime(2019, 11, 28),
+                               datetime(2020, 11, 26),
+                           ], )
+
+    def test_holidays_within_dates(self):
+        # Fix holiday behavior found in #11477
+        # where holiday.dates returned dates outside start/end date
+        # or observed rules could not be applied as the holiday
+        # was not in the original date range (e.g., 7/4/2015 -> 7/3/2015)
+        start_date = datetime(2015, 7, 1)
+        end_date = datetime(2015, 7, 1)
+
+        calendar = get_calendar('USFederalHolidayCalendar')
+        new_years = calendar.rule_from_name('New Years Day')
+        july_4th = calendar.rule_from_name('July 4th')
+        veterans_day = calendar.rule_from_name('Veterans Day')
+        christmas = calendar.rule_from_name('Christmas')
+
+        # Holiday: (start/end date, holiday)
+        holidays = {USMemorialDay: ("2015-05-25", "2015-05-25"),
+                    USLaborDay: ("2015-09-07", "2015-09-07"),
+                    USColumbusDay: ("2015-10-12", "2015-10-12"),
+                    USThanksgivingDay: ("2015-11-26", "2015-11-26"),
+                    USMartinLutherKingJr: ("2015-01-19", "2015-01-19"),
+                    USPresidentsDay: ("2015-02-16", "2015-02-16"),
+                    GoodFriday: ("2015-04-03", "2015-04-03"),
+                    EasterMonday: [("2015-04-06", "2015-04-06"),
+                                   ("2015-04-05", [])],
+                    new_years: [("2015-01-01", "2015-01-01"),
+                                ("2011-01-01", []),
+                                ("2010-12-31", "2010-12-31")],
+                    july_4th: [("2015-07-03", "2015-07-03"),
+                               ("2015-07-04", [])],
+                    veterans_day: [("2012-11-11", []),
+                                   ("2012-11-12", "2012-11-12")],
+                    christmas: [("2011-12-25", []),
+                                ("2011-12-26", "2011-12-26")]}
+
+        for rule, dates in compat.iteritems(holidays):
+            empty_dates = rule.dates(start_date, end_date)
+            assert empty_dates.tolist() == []
+
+            if isinstance(dates, tuple):
+                dates = [dates]
+
+            for start, expected in dates:
+                if len(expected):
+                    expected = [Timestamp(expected)]
+                self.check_results(rule, start, start, expected)
+
+    def test_argument_types(self):
+        holidays = USThanksgivingDay.dates(self.start_date, self.end_date)
+
+        holidays_1 = USThanksgivingDay.dates(
+            self.start_date.strftime('%Y-%m-%d'),
+            self.end_date.strftime('%Y-%m-%d'))
+
+        holidays_2 = USThanksgivingDay.dates(
+            Timestamp(self.start_date),
+            Timestamp(self.end_date))
+
+        tm.assert_index_equal(holidays, holidays_1)
+        tm.assert_index_equal(holidays, holidays_2)
+
+    def test_special_holidays(self):
+        base_date = [datetime(2012, 5, 28)]
+        holiday_1 = Holiday('One-Time', year=2012, month=5, day=28)
+        holiday_2 = Holiday('Range', month=5, day=28,
+                            start_date=datetime(2012, 1, 1),
+                            end_date=datetime(2012, 12, 31),
+                            offset=DateOffset(weekday=MO(1)))
+
+        assert base_date == holiday_1.dates(self.start_date, self.end_date)
+        assert base_date == holiday_2.dates(self.start_date, self.end_date)
+
+    def test_get_calendar(self):
+        class TestCalendar(AbstractHolidayCalendar):
+            rules = []
+
+        calendar = get_calendar('TestCalendar')
+        assert TestCalendar == calendar.__class__
+
+    def test_factory(self):
+        class_1 = HolidayCalendarFactory('MemorialDay',
+                                         AbstractHolidayCalendar,
+                                         USMemorialDay)
+        class_2 = HolidayCalendarFactory('Thansksgiving',
+                                         AbstractHolidayCalendar,
+                                         USThanksgivingDay)
+        class_3 = HolidayCalendarFactory('Combined', class_1, class_2)
+
+        assert len(class_1.rules) == 1
+        assert len(class_2.rules) == 1
+        assert len(class_3.rules) == 2
+
+
+class TestObservanceRules(object):
+
+    def setup_method(self, method):
+        self.we = datetime(2014, 4, 9)
+        self.th = datetime(2014, 4, 10)
+        self.fr = datetime(2014, 4, 11)
+        self.sa = datetime(2014, 4, 12)
+        self.su = datetime(2014, 4, 13)
+        self.mo = datetime(2014, 4, 14)
+        self.tu = datetime(2014, 4, 15)
+
+    def test_next_monday(self):
+        assert next_monday(self.sa) == self.mo
+        assert next_monday(self.su) == self.mo
+
+    def test_next_monday_or_tuesday(self):
+        assert next_monday_or_tuesday(self.sa) == self.mo
+        assert next_monday_or_tuesday(self.su) == self.tu
+        assert next_monday_or_tuesday(self.mo) == self.tu
+
+    def test_previous_friday(self):
+        assert previous_friday(self.sa) == self.fr
+        assert previous_friday(self.su) == self.fr
+
+    def test_sunday_to_monday(self):
+        assert sunday_to_monday(self.su) == self.mo
+
+    def test_nearest_workday(self):
+        assert nearest_workday(self.sa) == self.fr
+        assert nearest_workday(self.su) == self.mo
+        assert nearest_workday(self.mo) == self.mo
+
+    def test_weekend_to_monday(self):
+        assert weekend_to_monday(self.sa) == self.mo
+        assert weekend_to_monday(self.su) == self.mo
+        assert weekend_to_monday(self.mo) == self.mo
+
+    def test_next_workday(self):
+        assert next_workday(self.sa) == self.mo
+        assert next_workday(self.su) == self.mo
+        assert next_workday(self.mo) == self.tu
+
+    def test_previous_workday(self):
+        assert previous_workday(self.sa) == self.fr
+        assert previous_workday(self.su) == self.fr
+        assert previous_workday(self.tu) == self.mo
+
+    def test_before_nearest_workday(self):
+        assert before_nearest_workday(self.sa) == self.th
+        assert before_nearest_workday(self.su) == self.fr
+        assert before_nearest_workday(self.tu) == self.mo
+
+    def test_after_nearest_workday(self):
+        assert after_nearest_workday(self.sa) == self.mo
+        assert after_nearest_workday(self.su) == self.tu
+        assert after_nearest_workday(self.fr) == self.mo
+
+
+class TestFederalHolidayCalendar(object):
+
+    def test_no_mlk_before_1986(self):
+        # see gh-10278
+        class MLKCalendar(AbstractHolidayCalendar):
+            rules = [USMartinLutherKingJr]
+
+        holidays = MLKCalendar().holidays(start='1984',
+                                          end='1988').to_pydatetime().tolist()
+
+        # Testing to make sure holiday is not incorrectly observed before 1986
+        assert holidays == [datetime(1986, 1, 20, 0, 0),
+                            datetime(1987, 1, 19, 0, 0)]
+
+    def test_memorial_day(self):
+        class MemorialDay(AbstractHolidayCalendar):
+            rules = [USMemorialDay]
+
+        holidays = MemorialDay().holidays(start='1971',
+                                          end='1980').to_pydatetime().tolist()
+
+        # Fixes 5/31 error and checked manually against Wikipedia
+        assert holidays == [datetime(1971, 5, 31, 0, 0),
+                            datetime(1972, 5, 29, 0, 0),
+                            datetime(1973, 5, 28, 0, 0),
+                            datetime(1974, 5, 27, 0, 0),
+                            datetime(1975, 5, 26, 0, 0),
+                            datetime(1976, 5, 31, 0, 0),
+                            datetime(1977, 5, 30, 0, 0),
+                            datetime(1978, 5, 29, 0, 0),
+                            datetime(1979, 5, 28, 0, 0)]
+
+
+class TestHolidayConflictingArguments(object):
+
+    def test_both_offset_observance_raises(self):
+        # see gh-10217
+        with pytest.raises(NotImplementedError):
+            Holiday("Cyber Monday", month=11, day=1,
+                    offset=[DateOffset(weekday=SA(4))],
+                    observance=next_monday)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tslibs/test_api.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""Tests that the tslibs API is locked down"""
+
+from pandas._libs import tslibs
+
+
+def test_namespace():
+
+    submodules = ['ccalendar',
+                  'conversion',
+                  'fields',
+                  'frequencies',
+                  'nattype',
+                  'np_datetime',
+                  'offsets',
+                  'parsing',
+                  'period',
+                  'resolution',
+                  'strptime',
+                  'timedeltas',
+                  'timestamps',
+                  'timezones']
+
+    api = ['NaT',
+           'iNaT',
+           'is_null_datetimelike',
+           'OutOfBoundsDatetime',
+           'Period',
+           'IncompatibleFrequency',
+           'Timedelta',
+           'Timestamp',
+           'delta_to_nanoseconds',
+           'ints_to_pytimedelta',
+           'localize_pydatetime',
+           'normalize_date',
+           'tz_convert_single']
+
+    expected = set(submodules + api)
+    names = [x for x in dir(tslibs) if not x.startswith('__')]
+    assert set(names) == expected

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tslibs/test_array_to_datetime.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+from datetime import date, datetime
+
+from dateutil.tz.tz import tzoffset
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs import iNaT, tslib
+from pandas.compat.numpy import np_array_datetime64_compat
+
+import pandas.util.testing as tm
+
+
+@pytest.mark.parametrize("data,expected", [
+    (["01-01-2013", "01-02-2013"],
+     ["2013-01-01T00:00:00.000000000-0000",
+      "2013-01-02T00:00:00.000000000-0000"]),
+    (["Mon Sep 16 2013", "Tue Sep 17 2013"],
+     ["2013-09-16T00:00:00.000000000-0000",
+      "2013-09-17T00:00:00.000000000-0000"])
+])
+def test_parsing_valid_dates(data, expected):
+    arr = np.array(data, dtype=object)
+    result, _ = tslib.array_to_datetime(arr)
+
+    expected = np_array_datetime64_compat(expected, dtype="M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dt_string, expected_tz", [
+    ["01-01-2013 08:00:00+08:00", 480],
+    ["2013-01-01T08:00:00.000000000+0800", 480],
+    ["2012-12-31T16:00:00.000000000-0800", -480],
+    ["12-31-2012 23:00:00-01:00", -60]
+])
+def test_parsing_timezone_offsets(dt_string, expected_tz):
+    # 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, result_tz = tslib.array_to_datetime(arr)
+
+    tm.assert_numpy_array_equal(result, expected)
+    assert result_tz is pytz.FixedOffset(expected_tz)
+
+
+def test_parsing_non_iso_timezone_offset():
+    dt_string = "01-01-2013T00:00:00.000000000+0000"
+    arr = np.array([dt_string], dtype=object)
+
+    result, result_tz = tslib.array_to_datetime(arr)
+    expected = np.array([np.datetime64("2013-01-01 00:00:00.000000000")])
+
+    tm.assert_numpy_array_equal(result, expected)
+    assert result_tz is pytz.FixedOffset(0)
+
+
+def test_parsing_different_timezone_offsets():
+    # see gh-17697
+    data = ["2015-11-18 15:30:00+05:30", "2015-11-18 15:30:00+06:30"]
+    data = np.array(data, dtype=object)
+
+    result, result_tz = tslib.array_to_datetime(data)
+    expected = np.array([datetime(2015, 11, 18, 15, 30,
+                                  tzinfo=tzoffset(None, 19800)),
+                         datetime(2015, 11, 18, 15, 30,
+                                  tzinfo=tzoffset(None, 23400))],
+                        dtype=object)
+
+    tm.assert_numpy_array_equal(result, expected)
+    assert result_tz is None
+
+
+@pytest.mark.parametrize("data", [
+    ["-352.737091", "183.575577"],
+    ["1", "2", "3", "4", "5"]
+])
+def test_number_looking_strings_not_into_datetime(data):
+    # see gh-4601
+    #
+    # These strings don't look like datetimes, so
+    # they shouldn't be attempted to be converted.
+    arr = np.array(data, 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")])
+@pytest.mark.parametrize("errors", ["coerce", "raise"])
+def test_coerce_outside_ns_bounds(invalid_date, errors):
+    arr = np.array([invalid_date], dtype="object")
+    kwargs = dict(values=arr, errors=errors)
+
+    if errors == "raise":
+        msg = "Out of bounds nanosecond timestamp"
+
+        with pytest.raises(ValueError, match=msg):
+            tslib.array_to_datetime(**kwargs)
+    else:  # coerce.
+        result, _ = tslib.array_to_datetime(**kwargs)
+        expected = np.array([iNaT], dtype="M8[ns]")
+
+        tm.assert_numpy_array_equal(result, expected)
+
+
+def test_coerce_outside_ns_bounds_one_valid():
+    arr = np.array(["1/1/1000", "1/1/2000"], dtype=object)
+    result, _ = tslib.array_to_datetime(arr, errors="coerce")
+
+    expected = [iNaT, "2000-01-01T00:00:00.000000000-0000"]
+    expected = np_array_datetime64_compat(expected, dtype="M8[ns]")
+
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("errors", ["ignore", "coerce"])
+def test_coerce_of_invalid_datetimes(errors):
+    arr = np.array(["01-01-2013", "not_a_date", "1"], dtype=object)
+    kwargs = dict(values=arr, errors=errors)
+
+    if errors == "ignore":
+        # Without coercing, the presence of any invalid
+        # dates prevents any values from being converted.
+        result, _ = tslib.array_to_datetime(**kwargs)
+        tm.assert_numpy_array_equal(result, arr)
+    else:  # coerce.
+        # With coercing, the invalid dates becomes iNaT
+        result, _ = tslib.array_to_datetime(arr, errors="coerce")
+        expected = ["2013-01-01T00:00:00.000000000-0000",
+                    iNaT,
+                    iNaT]
+
+        tm.assert_numpy_array_equal(
+            result,
+            np_array_datetime64_compat(expected, dtype="M8[ns]"))
+
+
+def test_to_datetime_barely_out_of_bounds():
+    # see gh-19382, gh-19529
+    #
+    # 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)
+    msg = "Out of bounds nanosecond timestamp: 2262-04-11 23:47:16"
+
+    with pytest.raises(tslib.OutOfBoundsDatetime, match=msg):
+        tslib.array_to_datetime(arr)

benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/tests/tslibs/test_ccalendar.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import ccalendar
+
+
+@pytest.mark.parametrize("date_tuple,expected", [
+    ((2001, 3, 1), 60),
+    ((2004, 3, 1), 61),
+    ((1907, 12, 31), 365),  # End-of-year, non-leap year.
+    ((2004, 12, 31), 366),  # End-of-year, leap year.
+])
+def test_get_day_of_year_numeric(date_tuple, expected):
+    assert ccalendar.get_day_of_year(*date_tuple) == expected
+
+
+def test_get_day_of_year_dt():
+    dt = datetime.fromordinal(1 + np.random.randint(365 * 4000))
+    result = ccalendar.get_day_of_year(dt.year, dt.month, dt.day)
+
+    expected = (dt - dt.replace(month=1, day=1)).days + 1
+    assert result == expected