diff --git a/dask/array/core.py b/dask/array/core.py
index 75b7682de..3938fe3fe 100644
--- a/dask/array/core.py
+++ b/dask/array/core.py
@@ -4025,6 +4025,11 @@ def broadcast_arrays(*args, **kwargs):
     if kwargs:
         raise TypeError("unsupported keyword argument(s) provided")
 
+    # Unify uneven chunking
+    inds = [list(reversed(range(x.ndim))) for x in args]
+    uc_args = concat(zip(args, inds))
+    _, args = unify_chunks(*uc_args, warn=False)
+
     shape = broadcast_shapes(*(e.shape for e in args))
     chunks = broadcast_chunks(*(e.chunks for e in args))
 
diff --git a/dask/bag/core.py b/dask/bag/core.py
index c1bb53d9b..756b876c8 100644
--- a/dask/bag/core.py
+++ b/dask/bag/core.py
@@ -1601,7 +1601,10 @@ class Bag(DaskMethodsMixin):
         return [Delayed(k, dsk) for k in keys]
 
     def repartition(self, npartitions):
-        """ Coalesce bag into fewer partitions.
+        """ Changes the number of partitions of the bag.
+
+        This can be used to reduce or increase the number of partitions
+        of the bag.
 
         Examples
         --------
diff --git a/dask/dataframe/_compat.py b/dask/dataframe/_compat.py
new file mode 100644
index 000000000..16453b0ad
--- /dev/null
+++ b/dask/dataframe/_compat.py
@@ -0,0 +1,85 @@
+import string
+from distutils.version import LooseVersion
+
+import numpy as np
+import pandas as pd
+
+
+PANDAS_VERSION = LooseVersion(pd.__version__)
+PANDAS_GT_0230 = PANDAS_VERSION >= LooseVersion("0.23.0")
+PANDAS_GT_0240 = PANDAS_VERSION >= LooseVersion("0.24.0")
+PANDAS_GT_0250 = PANDAS_VERSION >= LooseVersion("0.25.0")
+PANDAS_GT_100 = PANDAS_VERSION >= LooseVersion("1.0.0rc0")
+HAS_INT_NA = PANDAS_GT_0240
+
+
+if PANDAS_GT_100:
+    import pandas.testing as tm  # noqa: F401
+else:
+    import pandas.util.testing as tm  # noqa: F401
+
+
+def assert_categorical_equal(left, right, *args, **kwargs):
+    if PANDAS_GT_100:
+        tm.assert_extension_array_equal(left, right, *args, **kwargs)
+        assert pd.api.types.is_categorical_dtype(
+            left.dtype
+        ), "{} is not categorical dtype".format(left)
+        assert pd.api.types.is_categorical_dtype(
+            right.dtype
+        ), "{} is not categorical dtype".format(right)
+    else:
+        return tm.assert_categorical_equal(left, right, *args, **kwargs)
+
+
+def assert_numpy_array_equal(left, right):
+    left_na = pd.isna(left)
+    right_na = pd.isna(right)
+    np.testing.assert_array_equal(left_na, right_na)
+
+    left_valid = left[~left_na]
+    right_valid = right[~right_na]
+    np.testing.assert_array_equal(left_valid, right_valid)
+
+
+def makeDataFrame():
+    data = np.random.randn(30, 4)
+    index = list(string.ascii_letters)[:30]
+    return pd.DataFrame(data, index=index, columns=list("ABCD"))
+
+
+def makeTimeDataFrame():
+    data = makeDataFrame()
+    data.index = makeDateIndex()
+    return data
+
+
+def makeTimeSeries():
+    return makeTimeDataFrame()["A"]
+
+
+def makeDateIndex(k=30, freq="B"):
+    return pd.date_range("2000", periods=k, freq=freq)
+
+
+def makeTimedeltaIndex(k=30, freq="D"):
+    return pd.timedelta_range("1 day", periods=k, freq=freq)
+
+
+def makeMissingDataframe():
+    df = makeDataFrame()
+    data = df.values
+    data = np.where(data > 1, np.nan, data)
+    return pd.DataFrame(data, index=df.index, columns=df.columns)
+
+
+def makeMixedDataFrame():
+    df = pd.DataFrame(
+        {
+            "A": [0.0, 1, 2, 3, 4],
+            "B": [0.0, 1, 0, 1, 0],
+            "C": ["foo{}".format(i) for i in range(5)],
+            "D": pd.date_range("2009-01-01", periods=5),
+        }
+    )
+    return df
diff --git a/dask/dataframe/core.py b/dask/dataframe/core.py
index 4052e9972..189e20632 100644
--- a/dask/dataframe/core.py
+++ b/dask/dataframe/core.py
@@ -413,9 +413,13 @@ class _Frame(DaskMethodsMixin, OperatorMethodMixin):
 
     def __repr__(self):
         data = self._repr_data().to_string(max_rows=5, show_dimensions=False)
-        return """Dask {klass} Structure:
+        _str_fmt = """Dask {klass} Structure:
 {data}
-Dask Name: {name}, {task} tasks""".format(
+Dask Name: {name}, {task} tasks"""
+        if len(self.columns) == 0:
+            data = data.partition("\n")[-1].replace("Index", "Divisions")
+            _str_fmt = "Empty {}".format(_str_fmt)
+        return _str_fmt.format(
             klass=self.__class__.__name__,
             data=data,
             name=key_split(self._name),
@@ -1709,9 +1713,11 @@ Dask Name: {name}, {task} tasks""".format(
                 self._meta_nonempty.select_dtypes(include=[np.timedelta64]).columns
             )
 
-            if count_timedeltas == len(self._meta.columns):
+            # pandas 1.0+ does not implement var on timedelta
+
+            if not PANDAS_GT_100 and count_timedeltas == len(self._meta.columns):
                 result = self._var_timedeltas(skipna, ddof, split_every)
-            elif count_timedeltas > 0:
+            elif not PANDAS_GT_100 and count_timedeltas > 0:
                 result = self._var_mixed(skipna, ddof, split_every)
             else:
                 result = self._var_numeric(skipna, ddof, split_every)
@@ -2109,7 +2115,11 @@ Dask Name: {name}, {task} tasks""".format(
 
             name2 = "{0}{1}-take-last".format(self._token_prefix, op_name)
             cumlast = map_partitions(
-                _take_last, cumpart, skipna, meta=pd.Series([]), token=name2
+                _take_last,
+                cumpart,
+                skipna,
+                meta=pd.Series([], dtype="float"),
+                token=name2,
             )
 
             suffix = tokenize(self)
@@ -2127,6 +2137,7 @@ Dask Name: {name}, {task} tasks""".format(
                 else:
                     # aggregate with previous cumulation results
                     layer[(cname, i)] = (
+                        methods._cum_aggregate_apply,
                         aggregate,
                         (cname, i - 1),
                         (cumlast._name, i - 1),
@@ -2336,7 +2347,12 @@ Dask Name: {name}, {task} tasks""".format(
         date = self.divisions[0] + offset
         end = self.loc._get_partitions(date)
 
-        include_right = offset.isAnchored() or not hasattr(offset, "_inc")
+        if PANDAS_GT_100:
+            is_anchored = offset.is_anchored()
+        else:
+            is_anchored = offset.isAnchored()
+
+        include_right = is_anchored or not hasattr(offset, "_inc")
 
         if end == self.npartitions - 1:
             divs = self.divisions
@@ -4285,8 +4301,14 @@ class DataFrame(_Frame):
     def _repr_data(self):
         meta = self._meta
         index = self._repr_divisions
-        series_list = [_repr_data_series(s, index=index) for _, s in meta.iteritems()]
-        return pd.concat(series_list, axis=1)
+        cols = meta.columns
+        if len(cols) == 0:
+            series_df = pd.DataFrame([[]] * len(index), columns=cols, index=index)
+        else:
+            series_df = pd.concat(
+                [_repr_data_series(s, index=index) for _, s in meta.iteritems()], axis=1
+            )
+        return series_df
 
     _HTML_FMT = """<div><strong>Dask DataFrame Structure:</strong></div>
 {data}
@@ -5113,7 +5135,7 @@ def quantile(df, q, method="default"):
         name = "quantiles-" + token
         empty_index = pd.Index([], dtype=float)
         return Series(
-            {(name, 0): pd.Series([], name=df.name, index=empty_index)},
+            {(name, 0): pd.Series([], name=df.name, index=empty_index, dtype="float")},
             name,
             df._meta,
             [None, None],
@@ -5386,7 +5408,7 @@ def _take_last(a, skipna=True):
             # create Series from appropriate backend dataframe library
             series_typ = type(a.iloc[0:1, 0])
             if a.empty:
-                return series_typ([])
+                return series_typ([], dtype="float")
             return series_typ(
                 {col: _last_valid(a[col]) for col in a.columns}, index=a.columns
             )
@@ -5886,13 +5908,18 @@ def maybe_shift_divisions(df, periods, freq):
     """
     if isinstance(freq, str):
         freq = pd.tseries.frequencies.to_offset(freq)
-    if isinstance(freq, pd.DateOffset) and (
-        freq.isAnchored() or not hasattr(freq, "delta")
-    ):
-        # Can't infer divisions on relative or anchored offsets, as
-        # divisions may now split identical index value.
-        # (e.g. index_partitions = [[1, 2, 3], [3, 4, 5]])
-        return df.clear_divisions()
+
+    is_offset = isinstance(freq, pd.DateOffset)
+    if is_offset:
+        if PANDAS_GT_100:
+            is_anchored = freq.is_anchored()
+        else:
+            is_anchored = freq.isAnchored()
+        if is_anchored or not hasattr(freq, "delta"):
+            # Can't infer divisions on relative or anchored offsets, as
+            # divisions may now split identical index value.
+            # (e.g. index_partitions = [[1, 2, 3], [3, 4, 5]])
+            return df.clear_divisions()
     if df.known_divisions:
         divs = pd.Series(range(len(df.divisions)), index=df.divisions)
         divisions = divs.shift(periods, freq=freq).index
diff --git a/dask/dataframe/groupby.py b/dask/dataframe/groupby.py
index eae981e56..3c9165a3c 100644
--- a/dask/dataframe/groupby.py
+++ b/dask/dataframe/groupby.py
@@ -51,7 +51,7 @@ from ..highlevelgraph import HighLevelGraph
 # operates on matching partitions of frame-like objects passed as varargs.
 #
 # After the initial chunk step, the passed index is implicitly passed along to
-# subsequent operations as the index of the parittions. Groupby operations on
+# subsequent operations as the index of the partitions. Groupby operations on
 # the individual partitions can then access the index via the ``levels``
 # parameter of the ``groupby`` function. The correct argument is determined by
 # the ``_determine_levels`` function.
@@ -126,7 +126,7 @@ def _groupby_raise_unaligned(df, **kwargs):
     """Groupby, but raise if df and `by` key are unaligned.
 
     Pandas supports grouping by a column that doesn't align with the input
-    frame/series/index. However, the reindexing this causes doesn't seem to be
+    frame/series/index. However, the reindexing does not seem to be
     threadsafe, and can result in incorrect results. Since grouping by an
     unaligned key is generally a bad idea, we just error loudly in dask.
 
diff --git a/dask/dataframe/io/parquet/arrow.py b/dask/dataframe/io/parquet/arrow.py
index 708a3ab7b..dd39282b0 100644
--- a/dask/dataframe/io/parquet/arrow.py
+++ b/dask/dataframe/io/parquet/arrow.py
@@ -326,7 +326,12 @@ class ArrowEngine(Engine):
         fs, piece, columns, index, categories=(), partitions=(), **kwargs
     ):
         if isinstance(index, list):
-            columns += index
+            for level in index:
+                # unclear if we can use set ops here. I think the order matters.
+                # Need the membership test to avoid duplicating index when
+                # we slice with `columns` later on.
+                if level not in columns:
+                    columns.append(level)
         if isinstance(piece, str):
             # `piece` is a file-path string
             piece = pq.ParquetDatasetPiece(
@@ -342,6 +347,16 @@ class ArrowEngine(Engine):
                 open_file_func=partial(fs.open, mode="rb"),
             )
 
+        # Ensure `columns` and `partitions` do not overlap
+        columns_and_parts = columns.copy()
+        if columns_and_parts and partitions:
+            for part_name in partitions.partition_names:
+                if part_name in columns:
+                    columns.remove(part_name)
+                else:
+                    columns_and_parts.append(part_name)
+            columns = columns or None
+
         df = piece.read(
             columns=columns,
             partitions=partitions,
@@ -349,7 +364,7 @@ class ArrowEngine(Engine):
             use_threads=False,
             **kwargs.get("read", {}),
         ).to_pandas(categories=categories, use_threads=False, ignore_metadata=True)[
-            list(columns)
+            list(columns_and_parts)
         ]
 
         if index:
diff --git a/dask/dataframe/methods.py b/dask/dataframe/methods.py
index 1c263e513..ebd27902e 100644
--- a/dask/dataframe/methods.py
+++ b/dask/dataframe/methods.py
@@ -231,6 +231,23 @@ def describe_nonnumeric_aggregate(stats, name):
     return pd.Series(values, index=index, name=name)
 
 
+def _cum_aggregate_apply(aggregate, x, y):
+    """ Apply aggregation function within a cumulative aggregation
+
+    Parameters
+    ----------
+    aggregate: function (a, a) -> a
+        The aggregation function, like add, which is used to and subsequent
+        results
+    x:
+    y:
+    """
+    if y is None:
+        return x
+    else:
+        return aggregate(x, y)
+
+
 def cummin_aggregate(x, y):
     if is_series_like(x) or is_dataframe_like(x):
         return x.where((x < y) | x.isnull(), y, axis=x.ndim - 1)
@@ -365,6 +382,9 @@ def concat_pandas(dfs, axis=0, join="outer", uniform=False, filter_warning=True)
     # Support concatenating indices along axis 0
     if isinstance(dfs[0], pd.Index):
         if isinstance(dfs[0], pd.CategoricalIndex):
+            for i in range(1, len(dfs)):
+                if not isinstance(dfs[i], pd.CategoricalIndex):
+                    dfs[i] = dfs[i].astype("category")
             return pd.CategoricalIndex(union_categoricals(dfs), name=dfs[0].name)
         elif isinstance(dfs[0], pd.MultiIndex):
             first, rest = dfs[0], dfs[1:]
diff --git a/dask/dataframe/multi.py b/dask/dataframe/multi.py
index 598176e09..1f15a1c7d 100644
--- a/dask/dataframe/multi.py
+++ b/dask/dataframe/multi.py
@@ -64,6 +64,7 @@ from pandas.api.types import is_dtype_equal
 from ..base import tokenize, is_dask_collection
 from ..highlevelgraph import HighLevelGraph
 from ..utils import apply
+from ._compat import PANDAS_GT_100
 from .core import (
     _Frame,
     DataFrame,
@@ -715,7 +716,10 @@ def concat_and_unsort(frames, columns):
 
 
 def _concat_compat(frames, left, right):
-    if PANDAS_GT_0230:
+    if PANDAS_GT_100:
+        # join_axes removed
+        return (pd.concat, frames, 0, "outer", False, None, None, None, False, False)
+    elif PANDAS_GT_0230:
         # (axis, join, join_axis, ignore_index, keys, levels, names, verify_integrity, sort)
         # we only care about sort, to silence warnings.
         return (
diff --git a/dask/dataframe/utils.py b/dask/dataframe/utils.py
index b77f14582..93b0c8de8 100644
--- a/dask/dataframe/utils.py
+++ b/dask/dataframe/utils.py
@@ -3,7 +3,6 @@ import numbers
 import re
 import textwrap
 from collections.abc import Iterator, Mapping
-from distutils.version import LooseVersion
 
 import sys
 import traceback
@@ -11,7 +10,6 @@ from contextlib import contextmanager
 
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 from pandas.api.types import (
     is_categorical_dtype,
     is_scalar,
@@ -21,6 +19,17 @@ from pandas.api.types import (
     is_interval_dtype,
 )
 
+# include these here for compat
+from ._compat import (  # noqa: F401
+    PANDAS_VERSION,
+    PANDAS_GT_0230,
+    PANDAS_GT_0240,
+    PANDAS_GT_0250,
+    PANDAS_GT_100,
+    HAS_INT_NA,
+    tm,
+)
+
 from .extensions import make_array_nonempty, make_scalar
 from ..base import is_dask_collection
 from ..core import get_deps
@@ -31,14 +40,6 @@ from ..utils import is_series_like as dask_is_series_like
 from ..utils import is_index_like as dask_is_index_like
 
 
-PANDAS_VERSION = LooseVersion(pd.__version__)
-PANDAS_GT_0230 = PANDAS_VERSION >= LooseVersion("0.23.0")
-PANDAS_GT_0240 = PANDAS_VERSION >= LooseVersion("0.24.0rc1")
-PANDAS_GT_0250 = PANDAS_VERSION >= LooseVersion("0.25.0")
-PANDAS_GT_100 = PANDAS_VERSION >= LooseVersion("0.26.0.dev0")
-HAS_INT_NA = PANDAS_GT_0240
-
-
 def is_integer_na_dtype(t):
     dtype = getattr(t, "dtype", t)
     if HAS_INT_NA:
diff --git a/dask/order.py b/dask/order.py
index 15a8fe52b..8aad68d7b 100644
--- a/dask/order.py
+++ b/dask/order.py
@@ -74,7 +74,8 @@ Work towards *small goals* with *big steps*.
     This relies on the regularity of graph constructors like dask.array to be a
     good proxy for ordering.  This is usually a good idea and a sane default.
 """
-from .core import get_dependencies, reverse_dict, get_deps  # noqa: F401
+from math import log
+from .core import get_dependencies, reverse_dict, get_deps, getcycle  # noqa: F401
 from .utils_test import add, inc  # noqa: F401
 
 
@@ -88,12 +89,12 @@ def order(dsk, dependencies=None):
     This currently traverses the graph as a single-threaded scheduler would
     traverse it.  It breaks ties in the following ways:
 
-    1.  Start from roots nodes that have the largest subgraphs
-    2.  When a node has dependencies that are not yet computed prefer
-        dependencies with large subtrees  (start hard things first)
-    2.  When we reach a node that can be computed we then traverse up and
-        prefer dependents that have small super-trees (few total dependents)
-        (finish existing work quickly)
+    1.  Begin at a leaf node that is a dependency of a root node that has the
+        largest subgraph (start hard things first)
+    2.  Prefer tall branches with few dependents (start hard things first and
+        try to avoid memory usage)
+    3.  Prefer dependents that are dependencies of root nodes that have
+        the smallest subgraph (do small goals that can terminate quickly)
 
     Examples
     --------
@@ -101,115 +102,381 @@ def order(dsk, dependencies=None):
     >>> order(dsk)
     {'a': 0, 'c': 1, 'b': 2, 'd': 3}
     """
+    if not dsk:
+        return {}
+
     if dependencies is None:
         dependencies = {k: get_dependencies(dsk, k) for k in dsk}
 
-    for k, deps in dependencies.items():
-        deps.discard(k)
-
     dependents = reverse_dict(dependencies)
+    num_needed, total_dependencies = ndependencies(dependencies, dependents)
+    metrics = graph_metrics(dependencies, dependents, total_dependencies)
+    if len(metrics) != len(dsk):
+        cycle = getcycle(dsk, None)
+        raise RuntimeError(
+            "Cycle detected between the following keys:\n  -> %s"
+            % "\n  -> ".join(str(x) for x in cycle)
+        )
+
+    # Leaf nodes.  We choose one--the initial node--for each weakly connected subgraph.
+    # Let's calculate the `initial_stack_key` as we determine `init_stack` set.
+    init_stack = {
+        # First prioritize large, tall groups, then prioritize the same as ``dependents_key``.
+        key: (
+            # at a high-level, work towards a large goal (and prefer tall and narrow)
+            -max_dependencies,
+            num_dependents - max_heights,
+            # tactically, finish small connected jobs first
+            min_dependencies,
+            num_dependents - min_heights,  # prefer tall and narrow
+            -total_dependents,  # take a big step
+            # try to be memory efficient
+            num_dependents,
+            # tie-breaker
+            StrComparable(key),
+        )
+        for key, num_dependents, (
+            total_dependents,
+            min_dependencies,
+            max_dependencies,
+            min_heights,
+            max_heights,
+        ) in (
+            (key, len(dependents[key]), metrics[key])
+            for key, val in dependencies.items()
+            if not val
+        )
+    }
+    # `initial_stack_key` chooses which task to run at the very beginning.
+    # This value is static, so we pre-compute as the value of this dict.
+    initial_stack_key = init_stack.__getitem__
 
-    total_dependencies = ndependencies(dependencies, dependents)
-    total_dependents, min_dependencies = ndependents(
-        dependencies, dependents, total_dependencies
-    )
-
-    waiting = {k: set(v) for k, v in dependencies.items()}
+    def dependents_key(x):
+        """ Choose a path from our starting task to our tactical goal
+
+        This path is connected to a large goal, but focuses on completing a small goal.
+        """
+        num_dependents = len(dependents[x])
+        total_dependents, min_dependencies, _, min_heights, _ = metrics[x]
+        return (
+            # tactically, finish small connected jobs first
+            min_dependencies,
+            num_dependents - min_heights,  # prefer tall and narrow
+            -total_dependents,  # take a big step
+            # try to be memory efficient
+            num_dependents - len(dependencies[x]) + num_needed[x],
+            num_dependents,
+            total_dependencies[x],  # already found work, so don't add more
+            # tie-breaker
+            StrComparable(x),
+        )
 
     def dependencies_key(x):
-        return total_dependencies.get(x, 0), ReverseStrComparable(x)
+        """ Choose which dependency to run as part of a reverse DFS
+
+        This is very similar to both ``initial_stack_key`` and ``dependents_key``.
+        """
+        num_dependents = len(dependents[x])
+        (
+            total_dependents,
+            min_dependencies,
+            max_dependencies,
+            min_heights,
+            max_heights,
+        ) = metrics[x]
+        # Prefer short and narrow instead of tall in narrow, because we're going in
+        # reverse along dependencies.
+        return (
+            # at a high-level, work towards a large goal (and prefer short and narrow)
+            -max_dependencies,
+            num_dependents + max_heights,
+            # tactically, finish small connected jobs first
+            min_dependencies,
+            num_dependents + min_heights,  # prefer short and narrow
+            -total_dependencies[x],  # go where the work is
+            # try to be memory efficient
+            num_dependents - len(dependencies[x]) + num_needed[x],
+            num_dependents,
+            total_dependents,  # already found work, so don't add more
+            # tie-breaker
+            StrComparable(x),
+        )
+
+    result = {}
+    i = 0
 
-    def dependents_key(x):
-        return (min_dependencies[x], -(total_dependents.get(x, 0)), StrComparable(x))
+    # Nodes in the current weakly connected subgraph that are not part of the current
+    # DFS along dependencies.  The next DFS will begin from these nodes.  `outer_stack`
+    # is populated from `init_stack` and the dependents of `outer_stack_seeds`.
+    outer_stack = []
+
+    # Nodes get added to this as they complete.  We will populate `outer_stack` from
+    # dependents of these nodes.  We consider nodes using a FIFO policy (yes, we could
+    # have used collections.deque, but a list with the current index is faster).
+    # Note that this does not include nodes with no dependents!
+    outer_stack_seeds = []
+    outer_stack_seeds_index = 0
+
+    # Used to perform a DFS along dependencies.  Once emptied (when traversing dependencies),
+    # this continues (along dependents) along a path from the initial (leaf) node down to a
+    # root node (a tactical goal).  This ensures this root node will get calculated before
+    # we consider any other dependents from `outer_stack_seeds`.
+    inner_stack = []
+
+    # aliases for speed
+    outer_stack_append = outer_stack.append
+    outer_stack_pop = outer_stack.pop
+    outer_stack_extend = outer_stack.extend
+    outer_stack_seeds_append = outer_stack_seeds.append
+    inner_stack_append = inner_stack.append
+    inner_stack_pop = inner_stack.pop
+    inner_stack_extend = inner_stack.extend
+    set_difference = set.difference
+
+    is_init_sorted = False
+    item = min(init_stack, key=initial_stack_key)
+    while True:
+        outer_stack_append(item)
+        while outer_stack:
+            item = outer_stack_pop()
+            if item not in result:
+                inner_stack_append(item)
+
+                while inner_stack:
+                    # Perform a DFS along dependencies until we complete our tactical goal
+                    item = inner_stack_pop()
+                    if item in result:
+                        continue
+
+                    if num_needed[item]:
+                        inner_stack_append(item)
+                        deps = set_difference(dependencies[item], result)
+                        if 1 < len(deps) < 1000:
+                            inner_stack_extend(
+                                sorted(deps, key=dependencies_key, reverse=True)
+                            )
+                        else:
+                            inner_stack_extend(deps)
+                        continue
+
+                    result[item] = i
+                    i += 1
+                    deps = dependents[item]
+
+                    if metrics[item][3] == 2:  # min_height
+                        # Don't leave any dangling single nodes!  Finish all dependents that are
+                        # ready and are also root nodes.  Doing this here also lets us continue
+                        # down to a different root node.
+                        finish_now = {
+                            dep
+                            for dep in deps
+                            if not dependents[dep] and num_needed[dep] == 1
+                        }
+                        if finish_now:
+                            deps -= finish_now
+                            if len(finish_now) > 1:
+                                finish_now = sorted(finish_now, key=dependents_key)
+                            for dep in finish_now:
+                                result[dep] = i
+                                i += 1
+
+                    if deps:
+                        for dep in deps:
+                            num_needed[dep] -= 1
+                        if not inner_stack:
+                            # Continue towards our tactical goal (an easy-to-compute root)
+                            if len(deps) == 1:
+                                inner_stack_extend(deps)
+                            else:
+                                # If there are many, many dependents, then calculating
+                                # `dependents_key` here could be relatively expensive.
+                                # However, this is still probably worth it tactically.
+                                inner_stack_append(min(deps, key=dependents_key))
+                                outer_stack_seeds_append(item)
+                        else:
+                            # Our next starting point will be "seeded" by a completed task in a
+                            # FIFO manner.  When our DFS with `inner_stack` is finished--which
+                            # means we computed our tactical goal--we will choose our next starting
+                            # point from the dependents of completed tasks.  However, it is too
+                            # expensive to consider all dependents of all completed tasks, so we
+                            # consider the dependents of tasks in the order they complete.
+                            outer_stack_seeds_append(item)
+
+            while not outer_stack and outer_stack_seeds_index < len(outer_stack_seeds):
+                # We wait for as long as possible to consider dependents of completed nodes:
+                # 1. some may have already completed, so waiting lets us sort fewer items, and
+                # 2. sorting via `dependents_key` depends on `num_needed`, which is dynamic.
+                deps = set_difference(
+                    dependents[outer_stack_seeds[outer_stack_seeds_index]], result
+                )
+                if deps:
+                    if 1 < len(deps) < 1000:
+                        outer_stack_extend(
+                            sorted(deps, key=dependents_key, reverse=True)
+                        )
+                    else:
+                        outer_stack_extend(deps)
+                outer_stack_seeds_index += 1
+
+        if len(dependencies) == len(result):
+            break  # all done!
+
+        # We just finished computing a connected group.
+        # Let's choose the first `item` in the next group to compute.
+        # If we have few large groups left, then it's best to find `item` by taking a minimum.
+        # If we have many small groups left, then it's best to sort.
+        # If we have many tiny groups left, then it's best to simply iterate.
+        if not is_init_sorted:
+            prev_len = len(init_stack)
+            if type(init_stack) is dict:
+                init_stack = set(init_stack)
+            init_stack = set_difference(init_stack, result)
+            N = len(init_stack)
+            m = prev_len - N
+            # is `min` likely better than `sort`?
+            if m >= N or N + (N - m) * log(N - m) < N * log(N):
+                item = min(init_stack, key=initial_stack_key)
+                continue
+
+            if len(init_stack) < 10000:
+                init_stack = sorted(init_stack, key=initial_stack_key, reverse=True)
+            else:
+                init_stack = list(init_stack)
+            init_stack_pop = init_stack.pop
+            is_init_sorted = True
+
+        item = init_stack_pop()
+        while item in result:
+            item = init_stack_pop()
 
-    result = dict()
-    seen = set()  # tasks that should not be added again to the stack
-    i = 0
+    return result
 
-    stack = [k for k, v in dependents.items() if not v]
-    if len(stack) < 10000:
-        stack = sorted(stack, key=dependencies_key)
-    else:
-        stack = stack[::-1]
 
-    while stack:
-        item = stack.pop()
+def graph_metrics(dependencies, dependents, total_dependencies):
+    r""" Useful measures of a graph used by ``dask.order.order``
 
-        if item in result:
-            continue
+    Example DAG (a1 has no dependencies; b2 and c1 are root nodes):
 
-        deps = waiting[item]
+    c1
+    |
+    b1  b2
+     \  /
+      a1
 
-        if deps:
-            stack.append(item)
-            seen.add(item)
-            if len(deps) < 1000:
-                deps = sorted(deps, key=dependencies_key)
-            stack.extend(deps)
-            continue
+    For each key we return:
+    1.  The number of keys that can only be run after this key is run.  The
+        root nodes have value 1 while deep child nodes will have larger values.
 
-        result[item] = i
-        i += 1
+        1
+        |
+        2   1
+         \ /
+          4
 
-        for dep in dependents[item]:
-            waiting[dep].discard(item)
+    2.  The minimum value of the total number of dependencies of
+        all final dependents (see module-level comment for more).
+        In other words, the minimum of ``ndependencies`` of root
+        nodes connected to the current node.
 
-        deps = [
-            d
-            for d in dependents[item]
-            if d not in result and not (d in seen and len(waiting[d]) > 1)
-        ]
-        if len(deps) < 1000:
-            deps = sorted(deps, key=dependents_key, reverse=True)
+        3
+        |
+        3   2
+         \ /
+          2
 
-        stack.extend(deps)
+    3.  The maximum value of the total number of dependencies of
+        all final dependents (see module-level comment for more).
+        In other words, the maximum of ``ndependencies`` of root
+        nodes connected to the current node.
 
-    return result
+        3
+        |
+        3   2
+         \ /
+          3
 
+    4.  The minimum height from a root node
 
-def ndependents(dependencies, dependents, total_dependencies):
-    """ Number of total data elements that depend on key
+        1
+        |
+        2   1
+         \ /
+          2
 
-    For each key we return the number of keys that can only be run after this
-    key is run.  The root nodes have value 1 while deep child nodes will have
-    larger values.
+    5.  The maximum height from a root node
 
-    We also return the minimum value of the maximum number of dependencies of
-    all final dependencies (see module-level comment for more)
+        1
+        |
+        2   1
+         \ /
+          3
 
     Examples
     --------
-    >>> dsk = {'a': 1, 'b': (inc, 'a'), 'c': (inc, 'b')}
+    >>> dsk = {'a1': 1, 'b1': (inc, 'a1'), 'b2': (inc, 'a1'), 'c1': (inc, 'b1')}
     >>> dependencies, dependents = get_deps(dsk)
-
-    >>> total_dependencies = ndependencies(dependencies, dependents)
-    >>> total_dependents, min_dependencies = ndependents(dependencies,
-    ...                                                  dependents,
-    ...                                                  total_dependencies)
-    >>> sorted(total_dependents.items())
-    [('a', 3), ('b', 2), ('c', 1)]
+    >>> _, total_dependencies = ndependencies(dependencies, dependents)
+    >>> metrics = graph_metrics(dependencies, dependents, total_dependencies)
+    >>> sorted(metrics.items())
+    [('a1', (4, 2, 3, 2, 3)), ('b1', (2, 3, 3, 2, 2)), ('b2', (1, 2, 2, 1, 1)), ('c1', (1, 3, 3, 1, 1))]
 
     Returns
     -------
-    total_dependendents: Dict[key, int]
-    min_dependencies: Dict[key, int]
+    metrics: Dict[key, Tuple[int, int, int, int, int]]
     """
-    result = dict()
-    min_result = dict()
-    num_needed = {k: len(v) for k, v in dependents.items()}
-    current = {k for k, v in num_needed.items() if v == 0}
+    result = {}
+    num_needed = {k: len(v) for k, v in dependents.items() if v}
+    current = []
+    current_pop = current.pop
+    current_append = current.append
+    for key, deps in dependents.items():
+        if not deps:
+            val = total_dependencies[key]
+            result[key] = (1, val, val, 1, 1)
+            for child in dependencies[key]:
+                num_needed[child] -= 1
+                if not num_needed[child]:
+                    current_append(child)
+
     while current:
-        key = current.pop()
-        result[key] = 1 + sum(result[parent] for parent in dependents[key])
-        try:
-            min_result[key] = min(min_result[parent] for parent in dependents[key])
-        except ValueError:
-            min_result[key] = total_dependencies[key]
+        key = current_pop()
+        parents = dependents[key]
+        if len(parents) == 1:
+            (parent,) = parents
+            (
+                total_dependents,
+                min_dependencies,
+                max_dependencies,
+                min_heights,
+                max_heights,
+            ) = result[parent]
+            result[key] = (
+                1 + total_dependents,
+                min_dependencies,
+                max_dependencies,
+                1 + min_heights,
+                1 + max_heights,
+            )
+        else:
+            (
+                total_dependents,
+                min_dependencies,
+                max_dependencies,
+                min_heights,
+                max_heights,
+            ) = zip(*(result[parent] for parent in dependents[key]))
+            result[key] = (
+                1 + sum(total_dependents),
+                min(min_dependencies),
+                max(max_dependencies),
+                1 + min(min_heights),
+                1 + max(max_heights),
+            )
         for child in dependencies[key]:
             num_needed[child] -= 1
-            if num_needed[child] == 0:
-                current.add(child)
-    return result, min_result
+            if not num_needed[child]:
+                current_append(child)
+    return result
 
 
 def ndependencies(dependencies, dependents):
@@ -222,20 +489,34 @@ def ndependencies(dependencies, dependents):
     --------
     >>> dsk = {'a': 1, 'b': (inc, 'a'), 'c': (inc, 'b')}
     >>> dependencies, dependents = get_deps(dsk)
-    >>> sorted(ndependencies(dependencies, dependents).items())
+    >>> num_dependencies, total_dependencies = ndependencies(dependencies, dependents)
+    >>> sorted(total_dependencies.items())
     [('a', 1), ('b', 2), ('c', 3)]
+
+    Returns
+    -------
+    num_dependencies: Dict[key, int]
+    total_dependencies: Dict[key, int]
     """
-    result = dict()
     num_needed = {k: len(v) for k, v in dependencies.items()}
-    current = {k for k, v in num_needed.items() if v == 0}
+    num_dependencies = num_needed.copy()
+    current = []
+    current_pop = current.pop
+    current_append = current.append
+    result = {k: 1 for k, v in dependencies.items() if not v}
+    for key in result:
+        for parent in dependents[key]:
+            num_needed[parent] -= 1
+            if not num_needed[parent]:
+                current_append(parent)
     while current:
-        key = current.pop()
+        key = current_pop()
         result[key] = 1 + sum(result[child] for child in dependencies[key])
         for parent in dependents[key]:
             num_needed[parent] -= 1
-            if num_needed[parent] == 0:
-                current.add(parent)
-    return result
+            if not num_needed[parent]:
+                current_append(parent)
+    return num_dependencies, result
 
 
 class StrComparable(object):
@@ -265,22 +546,3 @@ class StrComparable(object):
             return self.obj < other.obj
         except Exception:
             return str(self.obj) < str(other.obj)
-
-
-class ReverseStrComparable(object):
-    """ Wrap object so that it defaults to string comparison
-
-    Used when sorting in reverse direction.  See StrComparable for normal
-    documentation.
-    """
-
-    __slots__ = ("obj",)
-
-    def __init__(self, obj):
-        self.obj = obj
-
-    def __lt__(self, other):
-        try:
-            return self.obj > other.obj
-        except Exception:
-            return str(self.obj) > str(other.obj)
diff --git a/docs/source/custom-collections.rst b/docs/source/custom-collections.rst
index ba31ea684..30e5459b7 100644
--- a/docs/source/custom-collections.rst
+++ b/docs/source/custom-collections.rst
@@ -560,9 +560,12 @@ implementation. There are two ways to do this:
 
 2. Register a function with ``dask.base.normalize_token``
 
-   If defining a method on the class isn't possible, you can register a tokenize
-   function with the ``normalize_token`` dispatch.  The function should have the
-   same signature as described above.
+   If defining a method on the class isn't possible or you need to
+   customize the tokenize function for a class whose super-class is
+   already registered (for example if you need to sub-class built-ins),
+   you can register a tokenize function with the ``normalize_token``
+   dispatch.  The function should have the same signature as described
+   above.
 
 In both cases the implementation should be the same, where only the location of the
 definition is different.
diff --git a/docs/source/futures.rst b/docs/source/futures.rst
index fcc1f08c1..5b63f69ea 100644
--- a/docs/source/futures.rst
+++ b/docs/source/futures.rst
@@ -108,6 +108,9 @@ However, note that each task comes with about 1ms of overhead.  If you want to
 map a function over a large number of inputs, then you might consider
 :doc:`dask.bag <bag>` or :doc:`dask.dataframe <dataframe>` instead.
 
+.. note: See `this page <https://docs.dask.org/en/latest/graphs.html>`_ for
+   restrictions on what functions you use with Dask.
+
 Move Data
 ---------
 
diff --git a/docs/source/graphs.rst b/docs/source/graphs.rst
index f54f818fd..620e0ec0e 100644
--- a/docs/source/graphs.rst
+++ b/docs/source/graphs.rst
@@ -97,3 +97,51 @@ special and others can write different schedulers better suited to other
 applications or architectures easily.  Systems that emit dask graphs (like
 Dask Array, Dask Bag, and so on) may leverage the appropriate scheduler for
 the application and hardware.
+
+
+Task Expectations
+-----------------
+
+When a task is submitted to Dask for execution, there are a number of assumptions
+that are made about that task.
+
+Don't Modify Data In-Place
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In general, tasks with side-effects that alter the state of a future in-place
+are not recommended. Modifying data that is stored in Dask in-place can have
+unintended consequences. For example, consider a workflow involving a Numpy
+array:
+
+.. code-block:: python
+
+   from dask.distributed import Client
+   import numpy as np
+
+   client = Client()
+   x = client.submit(np.arange, 10)  # [0, 1, 2, 3, ...]
+
+   def f(arr):
+       arr[arr > 5] = 0  # modifies input directly without making a copy
+       arr += 1          # modifies input directly without making a copy
+       return arr
+
+   y = client.submit(f, x)
+
+In the example above Dask will update the values of the Numpy array
+``x`` in-place.  While efficient, this behavior can have unintended consequences,
+particularly if other tasks need to use ``x``, or if Dask needs to rerun this
+computation multiple times because of worker failure.
+
+
+Avoid Holding the GIL
+~~~~~~~~~~~~~~~~~~~~~
+
+Some Python functions that wrap external C/C++ code can hold onto the GIL,
+which stops other Python code from running in the background.  This is
+troublesome because while Dask workers run your function, they also need to
+communicate to each other in the background.
+
+If you wrap external code then please try to release the GIL.  This is usually
+easy to do if you are using any of the common solutions to code-wrapping like
+Cython, Numba, ctypes or others.

numpy.broadcast_array on dask array raises ValueError("Chunks do not align").
This is a regression. The old behaviour seems to be broadcast_array forces dask to perform a compute() to return arrays instead.

The new current behaviour seems to be going through the `__array_function__` protocol and perform a dask broadcast without automatic rechunking.

I am not sure when this has changed; and I don't know if there is anything we can do about this on the dask side -- eliminating implicit calls to compute() will surely cause some minor pains like this. 

An implicit rechunking is probably appropriate in this context, but I worry the operation may not always be well-defined (I couldn't think of an example where it is not.)

The stack trace
```
  File "<__array_function__ internals>", line 6, in broadcast_arrays
  File "/dev/shm/local/lib/python3.7/site-packages/dask/array/core.py", line 1359, in __array_function__
    return da_func(*args, **kwargs)
  File "/dev/shm/local/lib/python3.7/site-packages/dask/array/core.py", line 4025, in broadcast_arrays
    chunks = broadcast_chunks(*(e.chunks for e in args))
  File "/dev/shm/local/lib/python3.7/site-packages/dask/array/core.py", line 779, in broadcast_chunks
    raise ValueError("Chunks do not align: %s" % str(step2))
ValueError: Chunks do not align: [(55276, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 13022), (8568298,)]
```


diff --git a/dask/array/tests/test_array_core.py b/dask/array/tests/test_array_core.py
index bfe9b1e1f..f5a774aaa 100644
--- a/dask/array/tests/test_array_core.py
+++ b/dask/array/tests/test_array_core.py
@@ -971,6 +971,20 @@ def test_broadcast_arrays():
         assert_eq(e_a_r, e_d_r)
 
 
+def test_broadcast_arrays_uneven_chunks():
+    x = da.ones(30, chunks=(3,))
+    y = da.ones(30, chunks=(5,))
+    z = np.broadcast_arrays(x, y)
+
+    assert_eq(z, z)
+
+    x = da.ones((1, 30), chunks=(1, 3))
+    y = da.ones(30, chunks=(5,))
+    z = np.broadcast_arrays(x, y)
+
+    assert_eq(z, z)
+
+
 @pytest.mark.parametrize(
     "u_shape, v_shape",
     [
diff --git a/dask/bytes/tests/test_s3.py b/dask/bytes/tests/test_s3.py
index 871e54de9..050ba5ccb 100644
--- a/dask/bytes/tests/test_s3.py
+++ b/dask/bytes/tests/test_s3.py
@@ -386,6 +386,8 @@ def test_modification_time_read_bytes():
 @pytest.mark.parametrize("engine", ["pyarrow", "fastparquet"])
 def test_parquet(s3, engine):
     dd = pytest.importorskip("dask.dataframe")
+    from dask.dataframe._compat import tm
+
     lib = pytest.importorskip(engine)
     if engine == "pyarrow" and LooseVersion(lib.__version__) < "0.13.1":
         pytest.skip("pyarrow < 0.13.1 not supported for parquet")
@@ -415,7 +417,7 @@ def test_parquet(s3, engine):
     df2 = dd.read_parquet(url, index="foo", engine=engine)
     assert len(df2.divisions) > 1
 
-    pd.util.testing.assert_frame_equal(data, df2.compute())
+    tm.assert_frame_equal(data, df2.compute())
 
 
 def test_parquet_wstoragepars(s3):
diff --git a/dask/dataframe/io/tests/test_csv.py b/dask/dataframe/io/tests/test_csv.py
index 50ec4b7ab..fbf0bec12 100644
--- a/dask/dataframe/io/tests/test_csv.py
+++ b/dask/dataframe/io/tests/test_csv.py
@@ -11,10 +11,9 @@ dd = pytest.importorskip("dask.dataframe")
 
 from toolz import partition_all, valmap
 
-import pandas.util.testing as tm
-
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
 from dask.base import compute_as_if_collection
 from dask.dataframe.io.csv import (
     text_blocks_to_pandas,
@@ -673,7 +672,7 @@ def test_compression_multiple_files():
         f.write(csv_text.encode())
         f.close()
 
-        with tm.assert_produces_warning(UserWarning):
+        with pytest.warns(UserWarning):
             df = dd.read_csv(os.path.join(tdir, "*.csv.gz"), compression="gzip")
 
         assert len(df.compute()) == (len(csv_text.split("\n")) - 1) * 2
diff --git a/dask/dataframe/io/tests/test_demo.py b/dask/dataframe/io/tests/test_demo.py
index c6d0d7e00..f8bbb11a7 100644
--- a/dask/dataframe/io/tests/test_demo.py
+++ b/dask/dataframe/io/tests/test_demo.py
@@ -1,9 +1,9 @@
-import pandas.util.testing as tm
 import pandas as pd
 import pytest
 
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
 from dask.dataframe.utils import assert_eq
 
 
diff --git a/dask/dataframe/io/tests/test_hdf.py b/dask/dataframe/io/tests/test_hdf.py
index 9909c5990..0325860fb 100644
--- a/dask/dataframe/io/tests/test_hdf.py
+++ b/dask/dataframe/io/tests/test_hdf.py
@@ -1,6 +1,5 @@
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import pytest
 
 import os
@@ -9,10 +8,16 @@ import pathlib
 
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
 from dask.utils import tmpfile, tmpdir, dependency_depth
 from dask.dataframe.utils import assert_eq
 
 
+skip_pandas_rc = pytest.mark.xfail(
+    dd._compat.PANDAS_GT_100, reason="https://github.com/pandas-dev/pandas/issues/30962"
+)
+
+
 def test_to_hdf():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -44,6 +49,7 @@ def test_to_hdf():
         tm.assert_frame_equal(df, out[:])
 
 
+@skip_pandas_rc
 def test_to_hdf_multiple_nodes():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -124,6 +130,7 @@ def test_to_hdf_multiple_nodes():
             assert_eq(df16, out)
 
 
+@skip_pandas_rc
 def test_to_hdf_multiple_files():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -207,6 +214,7 @@ def test_to_hdf_multiple_files():
             assert_eq(df, out)
 
 
+@skip_pandas_rc
 def test_to_hdf_modes_multiple_nodes():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -255,6 +263,7 @@ def test_to_hdf_modes_multiple_nodes():
         assert_eq(df.append(df), out)
 
 
+@skip_pandas_rc
 def test_to_hdf_modes_multiple_files():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -367,6 +376,7 @@ def test_to_hdf_link_optimizations():
 
 
 @pytest.mark.slow
+@skip_pandas_rc
 def test_to_hdf_lock_delays():
     pytest.importorskip("tables")
     df16 = pd.DataFrame(
@@ -458,6 +468,7 @@ def test_to_hdf_exceptions():
 
 @pytest.mark.parametrize("scheduler", ["sync", "threads", "processes"])
 @pytest.mark.parametrize("npartitions", [1, 4, 10])
+@skip_pandas_rc
 def test_to_hdf_schedulers(scheduler, npartitions):
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -609,6 +620,7 @@ def test_to_fmt_warns():
         (pd.Series([1, 2, 3, 4], name="a"), tm.assert_series_equal),
     ],
 )
+@skip_pandas_rc
 def test_read_hdf(data, compare):
     pytest.importorskip("tables")
     with tmpfile("h5") as fn:
@@ -644,6 +656,7 @@ def test_read_hdf(data, compare):
         compare(a.compute(), sorted_data)
 
 
+@skip_pandas_rc
 def test_read_hdf_multiply_open():
     """Test that we can read from a file that's already opened elsewhere in
     read-only mode."""
@@ -657,6 +670,7 @@ def test_read_hdf_multiply_open():
             dd.read_hdf(fn, "/data", chunksize=2, mode="r")
 
 
+@skip_pandas_rc
 def test_read_hdf_multiple():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -710,6 +724,7 @@ def test_read_hdf_multiple():
         assert_eq(a, r)
 
 
+@skip_pandas_rc
 def test_read_hdf_start_stop_values():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -728,6 +743,7 @@ def test_read_hdf_start_stop_values():
             dd.read_hdf(fn, "/data", chunksize=-1)
 
 
+@skip_pandas_rc
 def test_hdf_globbing():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -765,6 +781,7 @@ def test_hdf_globbing():
             tm.assert_frame_equal(res.compute(), pd.concat([df] * 3))
 
 
+@skip_pandas_rc
 def test_hdf_file_list():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -781,6 +798,7 @@ def test_hdf_file_list():
             tm.assert_frame_equal(res.compute(), df)
 
 
+@skip_pandas_rc
 def test_read_hdf_pattern_pathlike():
     pytest.importorskip("tables")
     df = pd.DataFrame(
@@ -808,6 +826,7 @@ def test_to_hdf_path_pathlike():
         assert_eq(res, ddf)
 
 
+@skip_pandas_rc
 def test_read_hdf_doesnt_segfault():
     pytest.importorskip("tables")
     with tmpfile("h5") as fn:
diff --git a/dask/dataframe/io/tests/test_io.py b/dask/dataframe/io/tests/test_io.py
index 6f10b2a6c..e591fd11b 100644
--- a/dask/dataframe/io/tests/test_io.py
+++ b/dask/dataframe/io/tests/test_io.py
@@ -1,6 +1,5 @@
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 
 import pytest
 from threading import Lock
@@ -8,6 +7,7 @@ from multiprocessing.pool import ThreadPool
 
 import dask.array as da
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
 from dask.dataframe.io.io import _meta_from_array
 from dask.delayed import Delayed, delayed
 
@@ -263,7 +263,7 @@ def test_from_pandas_small():
             ddf = dd.from_pandas(df, npartitions=5, sort=sort)
             assert_eq(df, ddf)
 
-            s = pd.Series([0] * i, name="x")
+            s = pd.Series([0] * i, name="x", dtype=int)
             ds = dd.from_pandas(s, npartitions=5, sort=sort)
             assert_eq(s, ds)
 
diff --git a/dask/dataframe/io/tests/test_parquet.py b/dask/dataframe/io/tests/test_parquet.py
index 718216bfd..0a436b1c0 100644
--- a/dask/dataframe/io/tests/test_parquet.py
+++ b/dask/dataframe/io/tests/test_parquet.py
@@ -4,7 +4,6 @@ from distutils.version import LooseVersion
 
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import pytest
 
 import dask
@@ -908,7 +907,7 @@ def test_empty_partition(tmpdir, engine):
 
 def test_timestamp_index(tmpdir, engine):
     fn = str(tmpdir)
-    df = tm.makeTimeDataFrame()
+    df = dd._compat.makeTimeDataFrame()
     df.index.name = "foo"
     ddf = dd.from_pandas(df, npartitions=5)
     ddf.to_parquet(fn, engine=engine)
@@ -2243,3 +2242,17 @@ def test_roundtrip_pandas_chunksize(tmpdir, write_engine, read_engine):
     )
 
     assert_eq(pdf, ddf_read)
+
+
+def test_read_pandas_fastparquet_partitioned(tmpdir, engine):
+    check_fastparquet()
+
+    pdf = pd.DataFrame(
+        [{"str": str(i), "int": i, "group": "ABC"[i % 3]} for i in range(6)]
+    )
+    path = str(tmpdir)
+    pdf.to_parquet(path, partition_cols=["group"], engine="fastparquet")
+    ddf_read = dd.read_parquet(path, engine=engine)
+
+    assert len(ddf_read["group"].compute()) == 6
+    assert len(ddf_read.compute().group) == 6
diff --git a/dask/dataframe/tests/test_accessors.py b/dask/dataframe/tests/test_accessors.py
index b86c7fbb4..aafae2b91 100644
--- a/dask/dataframe/tests/test_accessors.py
+++ b/dask/dataframe/tests/test_accessors.py
@@ -47,7 +47,7 @@ def test_register(obj, registrar):
     with ensure_removed(obj, "mine"):
         before = set(dir(obj))
         registrar("mine")(MyAccessor)
-        instance = dd.from_pandas(obj._partition_type([]), 2)
+        instance = dd.from_pandas(obj._partition_type([], dtype=float), 2)
         assert instance.mine.prop == "item"
         after = set(dir(obj))
         assert (before ^ after) == {"mine"}
diff --git a/dask/dataframe/tests/test_arithmetics_reduction.py b/dask/dataframe/tests/test_arithmetics_reduction.py
index bf4c8affa..6998afc03 100644
--- a/dask/dataframe/tests/test_arithmetics_reduction.py
+++ b/dask/dataframe/tests/test_arithmetics_reduction.py
@@ -7,6 +7,7 @@ import pandas as pd
 from pandas.api.types import is_datetime64_ns_dtype
 
 import dask.dataframe as dd
+from dask.dataframe._compat import PANDAS_GT_100
 from dask.dataframe.utils import (
     assert_eq,
     assert_dask_graph,
@@ -799,17 +800,6 @@ def test_reductions_timedelta(split_every):
     ds = pd.Series(pd.to_timedelta([2, 3, 4, np.nan, 5]))
     dds = dd.from_pandas(ds, 2)
 
-    with pytest.warns(None):
-        # runtime warnings; https://github.com/dask/dask/issues/2381
-        assert_eq(dds.var(split_every=split_every), ds.var())
-        if not PANDAS_GT_0250:
-            # https://github.com/pandas-dev/pandas/issues/18880
-            assert_eq(
-                dds.var(split_every=split_every, skipna=False), ds.var(skipna=False)
-            )
-
-    assert_eq(dds.var(ddof=0, split_every=split_every), ds.var(ddof=0))
-
     assert_eq(dds.sum(split_every=split_every), ds.sum())
     assert_eq(dds.min(split_every=split_every), ds.min())
     assert_eq(dds.max(split_every=split_every), ds.max())
@@ -822,12 +812,12 @@ def test_reductions_timedelta(split_every):
         (
             pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=[0, 1, 3]),
             0,
-            pd.Series([]),
+            pd.Series([], dtype="float64"),
         ),
         (
             pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=[0, 1, 3]),
             1,
-            pd.Series([]),
+            pd.Series([], dtype="float64"),
         ),
         (pd.Series([1, 2.5, 6]), None, None),
     ],
@@ -1028,7 +1018,6 @@ def test_reductions_non_numeric_dtypes():
 
     # ToDo: pandas supports timedelta std, dask returns float64
     # assert_eq(dds.std(), pds.std())
-    assert_eq(dds.var(), pds.var())
 
     # ToDo: pandas supports timedelta std, otherwise dask raises:
     # TypeError: unsupported operand type(s) for *: 'float' and 'Timedelta'
@@ -1147,13 +1136,23 @@ def test_reductions_frame_dtypes():
     df_no_timedelta = df.drop("timedelta", axis=1, inplace=False)
     ddf_no_timedelta = dd.from_pandas(df_no_timedelta, 3)
 
-    assert_eq(df.sum(), ddf.sum())
+    if not PANDAS_GT_100:
+        # https://github.com/pandas-dev/pandas/issues/30886
+        assert_eq(df.sum(), ddf.sum())
+        assert_eq(df_no_timedelta.mean(), ddf_no_timedelta.mean())
+    else:
+        assert_eq(df.drop(columns="dt").sum(), ddf.drop(columns="dt").sum())
+        assert_eq(
+            df_no_timedelta.drop(columns="dt").mean(),
+            ddf_no_timedelta.drop(columns="dt").mean(),
+        )
+
     assert_eq(df.prod(), ddf.prod())
     assert_eq(df.min(), ddf.min())
     assert_eq(df.max(), ddf.max())
     assert_eq(df.count(), ddf.count())
     assert_eq(df_no_timedelta.std(), ddf_no_timedelta.std())
-    assert_eq(df.var(), ddf.var())
+    assert_eq(df_no_timedelta.var(), ddf_no_timedelta.var())
     if PANDAS_GT_0250:
         # https://github.com/pandas-dev/pandas/issues/18880
         assert_eq(
@@ -1176,8 +1175,6 @@ def test_reductions_frame_dtypes():
         assert_eq(df.var(ddof=0, skipna=False), ddf.var(ddof=0, skipna=False))
     assert_eq(df.sem(ddof=0), ddf.sem(ddof=0))
 
-    assert_eq(df_no_timedelta.mean(), ddf_no_timedelta.mean())
-
     assert_eq(df._get_numeric_data(), ddf._get_numeric_data())
 
     numerics = ddf[["int", "float"]]
diff --git a/dask/dataframe/tests/test_categorical.py b/dask/dataframe/tests/test_categorical.py
index be9ca91d1..07553c9e1 100644
--- a/dask/dataframe/tests/test_categorical.py
+++ b/dask/dataframe/tests/test_categorical.py
@@ -2,11 +2,12 @@ import operator
 
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import pytest
 
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
+from dask.dataframe import _compat
 from dask.dataframe.core import _concat
 from dask.dataframe.utils import (
     make_meta,
@@ -213,7 +214,7 @@ def test_categorize():
 
 def test_categorize_index():
     # Object dtype
-    ddf = dd.from_pandas(tm.makeDataFrame(), npartitions=5)
+    ddf = dd.from_pandas(_compat.makeDataFrame(), npartitions=5)
     df = ddf.compute()
 
     ddf2 = ddf.categorize()
diff --git a/dask/dataframe/tests/test_dataframe.py b/dask/dataframe/tests/test_dataframe.py
index bc72c972b..24f4408a2 100644
--- a/dask/dataframe/tests/test_dataframe.py
+++ b/dask/dataframe/tests/test_dataframe.py
@@ -5,13 +5,14 @@ from operator import add
 import pytest
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 from pandas.io.formats import format as pandas_format
 
 import dask
 import dask.array as da
 from dask.array.numpy_compat import _numpy_118
 import dask.dataframe as dd
+from dask.dataframe import _compat
+from dask.dataframe._compat import tm, PANDAS_GT_0230, PANDAS_GT_100
 from dask.base import compute_as_if_collection
 from dask.utils import put_lines, M
 
@@ -177,7 +178,7 @@ def test_attributes():
     assert "a" in dir(df)
     assert 5 not in dir(df)
 
-    df = dd.from_pandas(tm.makeTimeDataFrame(), npartitions=3)
+    df = dd.from_pandas(_compat.makeTimeDataFrame(), npartitions=3)
     pytest.raises(AttributeError, lambda: df.foo)
 
 
@@ -1542,7 +1543,7 @@ def test_dataframe_picklable():
     cloudpickle = pytest.importorskip("cloudpickle")
     cp_dumps = cloudpickle.dumps
 
-    d = tm.makeTimeDataFrame()
+    d = _compat.makeTimeDataFrame()
     df = dd.from_pandas(d, npartitions=3)
     df = df + 2
 
@@ -1926,7 +1927,7 @@ def test_embarrassingly_parallel_operations():
 
 
 def test_fillna():
-    df = tm.makeMissingDataframe(0.8, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=5, sort=False)
 
     assert_eq(ddf.fillna(100), df.fillna(100))
@@ -1958,7 +1959,8 @@ def test_fillna():
     pytest.raises(NotImplementedError, lambda: ddf.fillna(0, limit=10))
     pytest.raises(NotImplementedError, lambda: ddf.fillna(0, limit=10, axis=1))
 
-    df = tm.makeMissingDataframe(0.2, 42)
+    df = _compat.makeMissingDataframe()
+    df.iloc[:15, 0] = np.nan  # all NaN partition
     ddf = dd.from_pandas(df, npartitions=5, sort=False)
     pytest.raises(ValueError, lambda: ddf.fillna(method="pad").compute())
     assert_eq(df.fillna(method="pad", limit=3), ddf.fillna(method="pad", limit=3))
@@ -1975,7 +1977,7 @@ def test_fillna_duplicate_index():
 
 
 def test_fillna_multi_dataframe():
-    df = tm.makeMissingDataframe(0.8, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=5, sort=False)
 
     assert_eq(ddf.A.fillna(ddf.B), df.A.fillna(df.B))
@@ -1983,7 +1985,7 @@ def test_fillna_multi_dataframe():
 
 
 def test_ffill_bfill():
-    df = tm.makeMissingDataframe(0.8, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=5, sort=False)
 
     assert_eq(ddf.ffill(), df.ffill())
@@ -2115,14 +2117,18 @@ def test_select_dtypes(include, exclude):
 
     tm.assert_series_equal(result.dtypes.value_counts(), expected.dtypes.value_counts())
 
-    if PANDAS_VERSION >= "0.23.0":
-        ctx = pytest.warns(FutureWarning)
-    else:
-        ctx = pytest.warns(None)
-
-    with ctx:
-        tm.assert_series_equal(a.get_ftype_counts(), df.get_ftype_counts())
-        tm.assert_series_equal(result.get_ftype_counts(), expected.get_ftype_counts())
+    if not PANDAS_GT_100:
+        # removed in pandas 1.0
+        if PANDAS_GT_0230:
+            ctx = pytest.warns(FutureWarning)
+        else:
+            ctx = pytest.warns(None)
+
+        with ctx:
+            tm.assert_series_equal(a.get_ftype_counts(), df.get_ftype_counts())
+            tm.assert_series_equal(
+                result.get_ftype_counts(), expected.get_ftype_counts()
+            )
 
 
 def test_deterministic_apply_concat_apply_names():
@@ -2604,7 +2610,7 @@ def test_round():
 
 def test_cov():
     # DataFrame
-    df = pd.util.testing.makeMissingDataframe(0.3, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=6)
 
     res = ddf.cov()
@@ -2646,7 +2652,7 @@ def test_cov():
 
 def test_corr():
     # DataFrame
-    df = pd.util.testing.makeMissingDataframe(0.3, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=6)
 
     res = ddf.corr()
@@ -2694,7 +2700,7 @@ def test_corr():
 def test_corr_same_name():
     # Series with same names (see https://github.com/dask/dask/issues/4906)
 
-    df = pd.util.testing.makeMissingDataframe(0.3, 42)
+    df = _compat.makeMissingDataframe()
     ddf = dd.from_pandas(df, npartitions=6)
 
     result = ddf.A.corr(ddf.B.rename("A"))
@@ -2807,7 +2813,7 @@ def test_apply_infer_columns():
 
 
 def test_index_time_properties():
-    i = tm.makeTimeSeries()
+    i = _compat.makeTimeSeries()
     a = dd.from_pandas(i, npartitions=3)
 
     assert "day" in dir(a.index)
@@ -3027,6 +3033,7 @@ def _assert_info(df, ddf, memory_usage=True):
     stdout_pd = buf_pd.getvalue()
     stdout_da = buf_da.getvalue()
     stdout_da = stdout_da.replace(str(type(ddf)), str(type(df)))
+    # TODO
     assert stdout_pd == stdout_da
 
 
@@ -3137,7 +3144,7 @@ def test_gh_1301():
 
 
 def test_timeseries_sorted():
-    df = tm.makeTimeDataFrame()
+    df = _compat.makeTimeDataFrame()
     ddf = dd.from_pandas(df.reset_index(), npartitions=2)
     df.index.name = "index"
     assert_eq(ddf.set_index("index", sorted=True, drop=True), df)
@@ -3369,7 +3376,7 @@ def test_diff():
 
 
 def test_shift():
-    df = tm.makeTimeDataFrame()
+    df = _compat.makeTimeDataFrame()
     ddf = dd.from_pandas(df, npartitions=4)
 
     # DataFrame
@@ -3392,8 +3399,8 @@ def test_shift():
 
 @pytest.mark.parametrize("data_freq,divs1", [("B", False), ("D", True), ("H", True)])
 def test_shift_with_freq_DatetimeIndex(data_freq, divs1):
-    df = tm.makeTimeDataFrame(30)
-    df = df.set_index(tm.makeDateIndex(30, freq=data_freq))
+    df = _compat.makeTimeDataFrame()
+    df = df.set_index(_compat.makeDateIndex(30, freq=data_freq))
     ddf = dd.from_pandas(df, npartitions=4)
     for freq, divs2 in [("S", True), ("W", False), (pd.Timedelta(10, unit="h"), True)]:
         for d, p in [(ddf, df), (ddf.A, df.A), (ddf.index, df.index)]:
@@ -3408,7 +3415,7 @@ def test_shift_with_freq_DatetimeIndex(data_freq, divs1):
 
 @pytest.mark.parametrize("data_freq,divs", [("B", False), ("D", True), ("H", True)])
 def test_shift_with_freq_PeriodIndex(data_freq, divs):
-    df = tm.makeTimeDataFrame(30)
+    df = _compat.makeTimeDataFrame()
     # PeriodIndex
     df = df.set_index(pd.period_range("2000-01-01", periods=30, freq=data_freq))
     ddf = dd.from_pandas(df, npartitions=4)
@@ -3421,16 +3428,16 @@ def test_shift_with_freq_PeriodIndex(data_freq, divs):
     assert_eq(res, df.index.shift(2))
     assert res.known_divisions == divs
 
-    df = tm.makeTimeDataFrame(30)
+    df = _compat.makeTimeDataFrame()
     with pytest.raises(ValueError):
         ddf.index.shift(2, freq="D")  # freq keyword not supported
 
 
 def test_shift_with_freq_TimedeltaIndex():
-    df = tm.makeTimeDataFrame(30)
+    df = _compat.makeTimeDataFrame()
     # TimedeltaIndex
     for data_freq in ["T", "D", "H"]:
-        df = df.set_index(tm.makeTimedeltaIndex(30, freq=data_freq))
+        df = df.set_index(_compat.makeTimedeltaIndex(30, freq=data_freq))
         ddf = dd.from_pandas(df, npartitions=4)
         for freq in ["S", pd.Timedelta(10, unit="h")]:
             for d, p in [(ddf, df), (ddf.A, df.A), (ddf.index, df.index)]:
@@ -3445,7 +3452,7 @@ def test_shift_with_freq_TimedeltaIndex():
 
 def test_shift_with_freq_errors():
     # Other index types error
-    df = tm.makeDataFrame()
+    df = _compat.makeDataFrame()
     ddf = dd.from_pandas(df, npartitions=4)
     pytest.raises(NotImplementedError, lambda: ddf.shift(2, freq="S"))
     pytest.raises(NotImplementedError, lambda: ddf.A.shift(2, freq="S"))
@@ -3468,9 +3475,20 @@ def test_first_and_last(method):
             assert_eq(f(ddf.A, offset), f(df.A, offset))
 
 
+xfail_hash_object = pytest.mark.xfail(PANDAS_GT_100, reason="GH-30887")
+
+
 @pytest.mark.parametrize("npartitions", [1, 4, 20])
 @pytest.mark.parametrize("split_every", [2, 5])
-@pytest.mark.parametrize("split_out", [None, 1, 5, 20])
+@pytest.mark.parametrize(
+    "split_out",
+    [
+        None,
+        1,
+        pytest.param(5, marks=xfail_hash_object),
+        pytest.param(20, marks=xfail_hash_object),
+    ],
+)
 def test_hash_split_unique(npartitions, split_every, split_out):
     from string import ascii_lowercase
 
@@ -3987,13 +4005,13 @@ def test_scalar_with_array():
 
 def test_has_parallel_type():
     assert has_parallel_type(pd.DataFrame())
-    assert has_parallel_type(pd.Series())
+    assert has_parallel_type(pd.Series(dtype=float))
     assert not has_parallel_type(123)
 
 
 def test_meta_error_message():
     with pytest.raises(TypeError) as info:
-        dd.DataFrame({("x", 1): 123}, "x", pd.Series(), [None, None])
+        dd.DataFrame({("x", 1): 123}, "x", pd.Series(dtype=float), [None, None])
 
     assert "Series" in str(info.value)
     assert "DataFrame" in str(info.value)
@@ -4075,6 +4093,9 @@ def test_dtype_cast():
 @pytest.mark.parametrize("map_npart", [1, 3])
 @pytest.mark.parametrize("sorted_index", [False, True])
 @pytest.mark.parametrize("sorted_map_index", [False, True])
+@pytest.mark.xfail(
+    PANDAS_GT_100, reason="https://github.com/pandas-dev/pandas/issues/30887"
+)
 def test_series_map(base_npart, map_npart, sorted_index, sorted_map_index):
     base = pd.Series(
         ["".join(np.random.choice(["a", "b", "c"], size=3)) for x in range(100)]
@@ -4148,3 +4169,9 @@ def test_iter():
     assert list(df) == list(ddf)
     for col, expected in zip(ddf, ["A", "B"]):
         assert col == expected
+
+
+def test_dataframe_groupby_agg_empty_partitions():
+    df = pd.DataFrame({"x": [1, 2, 3, 4, 5, 6, 7, 8]})
+    ddf = dd.from_pandas(df, npartitions=4)
+    assert_eq(ddf[ddf.x < 5].x.cumsum(), df[df.x < 5].x.cumsum())
diff --git a/dask/dataframe/tests/test_format.py b/dask/dataframe/tests/test_format.py
index 72dd0f548..3ff74a86d 100644
--- a/dask/dataframe/tests/test_format.py
+++ b/dask/dataframe/tests/test_format.py
@@ -527,3 +527,41 @@ def test_duplicate_columns_repr():
     arr = da.from_array(np.arange(10).reshape(5, 2), chunks=(5, 2))
     frame = dd.from_dask_array(arr, columns=["a", "a"])
     repr(frame)
+
+
+def test_empty_repr():
+    df = pd.DataFrame()
+    ddf = dd.from_pandas(df, npartitions=1)
+    exp = (
+        "Empty Dask DataFrame Structure:\n"
+        "Columns: []\n"
+        "Divisions: [, ]\n"
+        "Dask Name: from_pandas, 1 tasks"
+    )
+    assert repr(ddf) == exp
+    exp_table = """<table border="1" class="dataframe">
+  <thead>
+    <tr style="text-align: right;">
+      <th></th>
+    </tr>
+    <tr>
+      <th>npartitions=1</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th></th>
+    </tr>
+    <tr>
+      <th></th>
+    </tr>
+  </tbody>
+</table>"""
+    exp = """<div><strong>Dask DataFrame Structure:</strong></div>
+<div>
+{style}{exp_table}
+</div>
+<div>Dask Name: from_pandas, 1 tasks</div>""".format(
+        style=style, exp_table=exp_table
+    )
+    assert ddf._repr_html_() == exp
diff --git a/dask/dataframe/tests/test_groupby.py b/dask/dataframe/tests/test_groupby.py
index 5dad375ff..3ef7cf017 100644
--- a/dask/dataframe/tests/test_groupby.py
+++ b/dask/dataframe/tests/test_groupby.py
@@ -4,12 +4,13 @@ from packaging import version
 
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 
 import pytest
 
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm, PANDAS_GT_100
+from dask.dataframe import _compat
 from dask.dataframe.utils import (
     assert_eq,
     assert_dask_graph,
@@ -475,7 +476,7 @@ def test_series_groupby_errors():
 
 
 def test_groupby_index_array():
-    df = tm.makeTimeDataFrame()
+    df = _compat.makeTimeDataFrame()
     ddf = dd.from_pandas(df, npartitions=2)
 
     # first select column, then group
@@ -494,7 +495,7 @@ def test_groupby_index_array():
 
 
 def test_groupby_set_index():
-    df = tm.makeTimeDataFrame()
+    df = _compat.makeTimeDataFrame()
     ddf = dd.from_pandas(df, npartitions=2)
     pytest.raises(TypeError, lambda: ddf.groupby(df.index.month, as_index=False))
 
@@ -681,7 +682,10 @@ def test_split_apply_combine_on_series(empty):
     pytest.raises(KeyError, lambda: ddf.groupby("x"))
     pytest.raises(KeyError, lambda: ddf.groupby(["a", "x"]))
     pytest.raises(KeyError, lambda: ddf.groupby("a")["x"])
-    pytest.raises(KeyError, lambda: ddf.groupby("a")["b", "x"])
+    with warnings.catch_warnings():
+        # pandas warns about using tuples before throwing the KeyError
+        warnings.simplefilter("ignore", FutureWarning)
+        pytest.raises(KeyError, lambda: ddf.groupby("a")["b", "x"])
     pytest.raises(KeyError, lambda: ddf.groupby("a")[["b", "x"]])
 
     # test graph node labels
@@ -878,7 +882,7 @@ def test_numeric_column_names():
 
 
 def test_groupby_apply_tasks():
-    df = pd.util.testing.makeTimeDataFrame()
+    df = _compat.makeTimeDataFrame()
     df["A"] = df.A // 0.1
     df["B"] = df.B // 0.1
     ddf = dd.from_pandas(df, npartitions=10)
@@ -974,11 +978,13 @@ def test_aggregate__examples(spec, split_every, grouper):
     # Warning from pandas deprecation .agg(dict[dict])
     # it's from pandas, so no reason to assert the deprecation warning,
     # but we should still test it for now
-    with pytest.warns(None):
-        assert_eq(
-            pdf.groupby(grouper(pdf)).agg(spec),
-            ddf.groupby(grouper(ddf)).agg(spec, split_every=split_every),
-        )
+    if not PANDAS_GT_100:
+        # removed in pandas 1.0
+        with pytest.warns(None):
+            assert_eq(
+                pdf.groupby(grouper(pdf)).agg(spec),
+                ddf.groupby(grouper(ddf)).agg(spec, split_every=split_every),
+            )
 
 
 @pytest.mark.parametrize(
@@ -1013,11 +1019,13 @@ def test_series_aggregate__examples(spec, split_every, grouper):
     # Warning from pandas deprecation .agg(dict[dict])
     # it's from pandas, so no reason to assert the deprecation warning,
     # but we should still test it for now
-    with pytest.warns(None):
-        assert_eq(
-            ps.groupby(grouper(pdf)).agg(spec),
-            ds.groupby(grouper(ddf)).agg(spec, split_every=split_every),
-        )
+    if not PANDAS_GT_100:
+        # removed in pandas 1.0
+        with pytest.warns(None):
+            assert_eq(
+                ps.groupby(grouper(pdf)).agg(spec),
+                ds.groupby(grouper(ddf)).agg(spec, split_every=split_every),
+            )
 
 
 def test_aggregate__single_element_groups(agg_func):
@@ -2281,7 +2289,7 @@ def test_groupby_dropna_cudf(dropna, by):
         dask_result = ddf.groupby(by, dropna=dropna).e.sum()
         cudf_result = df.groupby(by, dropna=dropna).e.sum()
     if by in ["c", "d"]:
-        # Loose string/category index name in cudf...
+        # Lose string/category index name in cudf...
         dask_result = dask_result.compute()
         dask_result.index.name = cudf_result.index.name
 
@@ -2296,3 +2304,28 @@ def test_rounding_negative_var():
 
     ddf = dd.from_pandas(df, npartitions=2)
     assert_eq(ddf.groupby("ids").x.std(), df.groupby("ids").x.std())
+
+
+@pytest.mark.parametrize("split_out", [2, 3])
+@pytest.mark.parametrize("column", [["b", "c"], ["b", "d"], ["b", "e"]])
+def test_groupby_split_out_multiindex(split_out, column):
+    df = pd.DataFrame(
+        {
+            "a": np.arange(8),
+            "b": [1, 0, 0, 2, 1, 1, 2, 0],
+            "c": [0, 1] * 4,
+            "d": ["dog", "cat", "cat", "dog", "dog", "dog", "cat", "bird"],
+        }
+    ).fillna(0)
+    df["e"] = df["d"].astype("category")
+    ddf = dd.from_pandas(df, npartitions=3)
+
+    ddf_result_so1 = (
+        ddf.groupby(column).a.mean(split_out=1).compute().sort_values().dropna()
+    )
+
+    ddf_result = (
+        ddf.groupby(column).a.mean(split_out=split_out).compute().sort_values().dropna()
+    )
+
+    assert_eq(ddf_result, ddf_result_so1, check_index=False)
diff --git a/dask/dataframe/tests/test_hashing.py b/dask/dataframe/tests/test_hashing.py
index ca37bbb1a..d046efb62 100644
--- a/dask/dataframe/tests/test_hashing.py
+++ b/dask/dataframe/tests/test_hashing.py
@@ -1,7 +1,8 @@
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import dask.dataframe as dd
+from dask.dataframe import _compat
+from dask.dataframe._compat import tm, PANDAS_GT_100
 from pandas.util import hash_pandas_object
 
 import pytest
@@ -20,11 +21,11 @@ from dask.dataframe.utils import assert_eq
         pd.Index([1, 2, 3]),
         pd.Index([True, False, True]),
         pd.DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
-        pd.util.testing.makeMissingDataframe(),
-        pd.util.testing.makeMixedDataFrame(),
-        pd.util.testing.makeTimeDataFrame(),
-        pd.util.testing.makeTimeSeries(),
-        pd.util.testing.makeTimedeltaIndex(),
+        _compat.makeMissingDataframe(),
+        _compat.makeMixedDataFrame(),
+        _compat.makeTimeDataFrame(),
+        _compat.makeTimeSeries(),
+        _compat.makeTimedeltaIndex(),
     ],
 )
 def test_hash_pandas_object(obj):
@@ -64,16 +65,24 @@ def test_object_missing_values():
     tm.assert_series_equal(h1, h2)
 
 
+xfail_hash_object = pytest.mark.xfail(
+    PANDAS_GT_100, reason="https://github.com/pandas-dev/pandas/issues/30887"
+)
+
+
 @pytest.mark.parametrize(
     "obj",
     [
         pd.Index([1, 2, 3]),
-        pd.Index([True, False, True], index=[1.5, 1.1, 3.3]),
+        pytest.param(pd.Index([True, False, True]), marks=xfail_hash_object),
         pd.Series([1, 2, 3]),
         pd.Series([1.0, 1.5, 3.2]),
         pd.Series([1.0, 1.5, 3.2], index=[1.5, 1.1, 3.3]),
         pd.DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
-        pd.DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}, index=["a", "z", "x"]),
+        pytest.param(
+            pd.DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}, index=["a", "z", "x"]),
+            marks=xfail_hash_object,
+        ),
     ],
 )
 def test_hash_object_dispatch(obj):
diff --git a/dask/dataframe/tests/test_indexing.py b/dask/dataframe/tests/test_indexing.py
index 68cf5b7e7..3c10de580 100644
--- a/dask/dataframe/tests/test_indexing.py
+++ b/dask/dataframe/tests/test_indexing.py
@@ -1,11 +1,11 @@
 import pandas as pd
-import pandas.util.testing as tm
 import numpy as np
 
 import pytest
 
 import dask.dataframe as dd
 
+from dask.dataframe._compat import tm, PANDAS_GT_100
 from dask.dataframe.indexing import _coerce_loc_index
 from dask.dataframe.utils import assert_eq, make_meta, PANDAS_VERSION
 
@@ -37,24 +37,30 @@ def test_loc():
     else:
         expected_warning = None
 
-    with pytest.warns(expected_warning):
-        assert_eq(d.loc[[3, 4, 1, 8]], full.loc[[3, 4, 1, 8]])
-    with pytest.warns(expected_warning):
-        assert_eq(d.loc[[3, 4, 1, 9]], full.loc[[3, 4, 1, 9]])
-    with pytest.warns(expected_warning):
-        assert_eq(d.loc[np.array([3, 4, 1, 9])], full.loc[np.array([3, 4, 1, 9])])
+    if not PANDAS_GT_100:
+        # removed in pandas 1.0
+        with pytest.warns(expected_warning):
+            assert_eq(d.loc[[3, 4, 1, 8]], full.loc[[3, 4, 1, 8]])
+        with pytest.warns(expected_warning):
+            assert_eq(d.loc[[3, 4, 1, 9]], full.loc[[3, 4, 1, 9]])
+        with pytest.warns(expected_warning):
+            assert_eq(d.loc[np.array([3, 4, 1, 9])], full.loc[np.array([3, 4, 1, 9])])
 
     assert_eq(d.a.loc[5], full.a.loc[5:5])
     assert_eq(d.a.loc[3:8], full.a.loc[3:8])
     assert_eq(d.a.loc[:8], full.a.loc[:8])
     assert_eq(d.a.loc[3:], full.a.loc[3:])
     assert_eq(d.a.loc[[5]], full.a.loc[[5]])
-    with pytest.warns(expected_warning):
-        assert_eq(d.a.loc[[3, 4, 1, 8]], full.a.loc[[3, 4, 1, 8]])
-    with pytest.warns(expected_warning):
-        assert_eq(d.a.loc[[3, 4, 1, 9]], full.a.loc[[3, 4, 1, 9]])
-    with pytest.warns(expected_warning):
-        assert_eq(d.a.loc[np.array([3, 4, 1, 9])], full.a.loc[np.array([3, 4, 1, 9])])
+    if not PANDAS_GT_100:
+        # removed in pandas 1.0
+        with pytest.warns(expected_warning):
+            assert_eq(d.a.loc[[3, 4, 1, 8]], full.a.loc[[3, 4, 1, 8]])
+        with pytest.warns(expected_warning):
+            assert_eq(d.a.loc[[3, 4, 1, 9]], full.a.loc[[3, 4, 1, 9]])
+        with pytest.warns(expected_warning):
+            assert_eq(
+                d.a.loc[np.array([3, 4, 1, 9])], full.a.loc[np.array([3, 4, 1, 9])]
+            )
     assert_eq(d.a.loc[[]], full.a.loc[[]])
     assert_eq(d.a.loc[np.array([])], full.a.loc[np.array([])])
 
@@ -82,8 +88,8 @@ def test_loc_non_informative_index():
 
 
 def test_loc_with_text_dates():
-    A = tm.makeTimeSeries(10).iloc[:5]
-    B = tm.makeTimeSeries(10).iloc[5:]
+    A = dd._compat.makeTimeSeries().iloc[:5]
+    B = dd._compat.makeTimeSeries().iloc[5:]
     s = dd.Series(
         {("df", 0): A, ("df", 1): B},
         "df",
@@ -168,6 +174,7 @@ def test_loc2d():
         d.a.loc[d.a % 2 == 0, 3]
 
 
+@pytest.mark.skip(PANDAS_GT_100, reason="Removed in pandas 1.0")
 def test_loc2d_some_missing():
     with pytest.warns(FutureWarning):
         assert_eq(d.loc[[3, 4, 3], ["a"]], full.loc[[3, 4, 3], ["a"]])
diff --git a/dask/dataframe/tests/test_multi.py b/dask/dataframe/tests/test_multi.py
index 34e67f6a6..1e1957c6a 100644
--- a/dask/dataframe/tests/test_multi.py
+++ b/dask/dataframe/tests/test_multi.py
@@ -4,9 +4,9 @@ import dask
 import dask.dataframe as dd
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 
 from dask.base import compute_as_if_collection
+from dask.dataframe._compat import tm, PANDAS_GT_100
 from dask.dataframe.core import _Frame
 from dask.dataframe.methods import concat, concat_kwargs
 from dask.dataframe.multi import (
@@ -221,7 +221,8 @@ def list_eq(aa, bb):
     else:
         av = a.sort_values().values
         bv = b.sort_values().values
-    tm.assert_numpy_array_equal(av, bv)
+
+    dd._compat.assert_numpy_array_equal(av, bv)
 
 
 @pytest.mark.parametrize("how", ["inner", "left", "right", "outer"])
@@ -1822,20 +1823,10 @@ def test_append2():
 
     assert_eq(ddf1.append(ddf2), ddf1.compute().append(ddf2.compute(), **concat_kwargs))
     assert_eq(ddf2.append(ddf1), ddf2.compute().append(ddf1.compute(), **concat_kwargs))
-    # Series + DataFrame
-    with pytest.warns(None):
-        # RuntimeWarning from pandas on comparing int and str
-        assert_eq(ddf1.a.append(ddf2), ddf1.a.compute().append(ddf2.compute()))
-        assert_eq(ddf2.a.append(ddf1), ddf2.a.compute().append(ddf1.compute()))
 
     # different columns
     assert_eq(ddf1.append(ddf3), ddf1.compute().append(ddf3.compute(), **concat_kwargs))
     assert_eq(ddf3.append(ddf1), ddf3.compute().append(ddf1.compute(), **concat_kwargs))
-    # Series + DataFrame
-    with pytest.warns(None):
-        # RuntimeWarning from pandas on comparing int and str
-        assert_eq(ddf1.a.append(ddf3), ddf1.a.compute().append(ddf3.compute()))
-        assert_eq(ddf3.b.append(ddf1), ddf3.b.compute().append(ddf1.compute()))
 
     # Dask + pandas
     assert_eq(
@@ -1846,15 +1837,6 @@ def test_append2():
         ddf2.append(ddf1.compute()),
         ddf2.compute().append(ddf1.compute(), **concat_kwargs),
     )
-    # Series + DataFrame
-    with pytest.warns(None):
-        # RuntimeWarning from pandas on comparing int and str
-        assert_eq(
-            ddf1.a.append(ddf2.compute()), ddf1.a.compute().append(ddf2.compute())
-        )
-        assert_eq(
-            ddf2.a.append(ddf1.compute()), ddf2.a.compute().append(ddf1.compute())
-        )
 
     # different columns
     assert_eq(
@@ -1865,15 +1847,6 @@ def test_append2():
         ddf3.append(ddf1.compute()),
         ddf3.compute().append(ddf1.compute(), **concat_kwargs),
     )
-    # Series + DataFrame
-    with pytest.warns(None):
-        # RuntimeWarning from pandas on comparing int and str
-        assert_eq(
-            ddf1.a.append(ddf3.compute()), ddf1.a.compute().append(ddf3.compute())
-        )
-        assert_eq(
-            ddf3.b.append(ddf1.compute()), ddf3.b.compute().append(ddf1.compute())
-        )
 
 
 def test_append_categorical():
@@ -1971,6 +1944,9 @@ def test_multi_duplicate_divisions():
     assert_eq(r1, r2)
 
 
+@pytest.mark.xfail(
+    PANDAS_GT_100, reason="https://github.com/pandas-dev/pandas/issues/30887"
+)
 def test_merge_outer_empty():
     # Issue #5470 bug reproducer
     k_clusters = 3
diff --git a/dask/dataframe/tests/test_reshape.py b/dask/dataframe/tests/test_reshape.py
index 910cdccfd..829663ef4 100644
--- a/dask/dataframe/tests/test_reshape.py
+++ b/dask/dataframe/tests/test_reshape.py
@@ -1,10 +1,10 @@
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import pytest
 
 import dask.dataframe as dd
 
+from dask.dataframe._compat import tm
 from dask.dataframe.utils import assert_eq, make_meta, PANDAS_VERSION, PANDAS_GT_0240
 
 
diff --git a/dask/dataframe/tests/test_shuffle.py b/dask/dataframe/tests/test_shuffle.py
index f80ae0b35..91ecb4087 100644
--- a/dask/dataframe/tests/test_shuffle.py
+++ b/dask/dataframe/tests/test_shuffle.py
@@ -9,10 +9,10 @@ import numpy as np
 import string
 import multiprocessing as mp
 from copy import copy
-import pandas.util.testing as tm
 
 import dask
 import dask.dataframe as dd
+from dask.dataframe._compat import tm, PANDAS_GT_100, assert_categorical_equal
 from dask import delayed
 from dask.base import compute_as_if_collection
 from dask.dataframe.shuffle import (
@@ -142,6 +142,9 @@ def test_partitioning_index():
     assert len(np.unique(res)) > 1
 
 
+@pytest.mark.xfail(
+    PANDAS_GT_100, reason="https://github.com/pandas-dev/pandas/issues/30887"
+)
 def test_partitioning_index_categorical_on_values():
     df = pd.DataFrame({"a": list(string.ascii_letters), "b": [1, 2, 3, 4] * 13})
     df.a = df.a.astype("category")
@@ -752,7 +755,7 @@ def test_set_index_categorical():
 
     # sorted with the metric defined by the Categorical
     divisions = pd.Categorical(result.divisions, dtype=dtype)
-    tm.assert_categorical_equal(divisions, divisions.sort_values())
+    assert_categorical_equal(divisions, divisions.sort_values())
 
 
 def test_compute_divisions():
diff --git a/dask/dataframe/tests/test_ufunc.py b/dask/dataframe/tests/test_ufunc.py
index 74c6de606..a74bddaa4 100644
--- a/dask/dataframe/tests/test_ufunc.py
+++ b/dask/dataframe/tests/test_ufunc.py
@@ -1,7 +1,6 @@
 import pytest
 
 pd = pytest.importorskip("pandas")
-import pandas.util.testing as tm
 
 import numpy as np
 
@@ -183,10 +182,10 @@ def test_ufunc_array_wrap(ufunc):
     assert_eq(dafunc(ds), pd.Series(npfunc(s), index=s.index))
 
     assert isinstance(npfunc(ds), np.ndarray)
-    tm.assert_numpy_array_equal(npfunc(ds), npfunc(s))
+    np.testing.assert_equal(npfunc(ds), npfunc(s))
 
     assert isinstance(dafunc(s), np.ndarray)
-    tm.assert_numpy_array_equal(dafunc(s), npfunc(s))
+    np.testing.assert_array_equal(dafunc(s), npfunc(s))
 
     df = pd.DataFrame(
         {
@@ -205,10 +204,10 @@ def test_ufunc_array_wrap(ufunc):
     assert_eq(dafunc(ddf), exp)
 
     assert isinstance(npfunc(ddf), np.ndarray)
-    tm.assert_numpy_array_equal(npfunc(ddf), npfunc(df))
+    np.testing.assert_array_equal(npfunc(ddf), npfunc(df))
 
     assert isinstance(dafunc(df), np.ndarray)
-    tm.assert_numpy_array_equal(dafunc(df), npfunc(df))
+    np.testing.assert_array_equal(dafunc(df), npfunc(df))
 
 
 _UFUNCS_2ARG = [
@@ -453,7 +452,7 @@ def test_2args_with_array(ufunc, pandas, darray):
     assert isinstance(dafunc(dask, darray), dask_type)
     assert isinstance(dafunc(darray, dask), dask_type)
 
-    tm.assert_numpy_array_equal(
+    np.testing.assert_array_equal(
         dafunc(dask, darray).compute().values, npfunc(pandas.values, darray).compute()
     )
 
@@ -461,10 +460,10 @@ def test_2args_with_array(ufunc, pandas, darray):
     assert isinstance(npfunc(dask, darray), dask_type)
     assert isinstance(npfunc(darray, dask), dask_type)
 
-    tm.assert_numpy_array_equal(
+    np.testing.assert_array_equal(
         npfunc(dask, darray).compute().values, npfunc(pandas.values, darray.compute())
     )
-    tm.assert_numpy_array_equal(
+    np.testing.assert_array_equal(
         npfunc(darray, dask).compute().values, npfunc(darray.compute(), pandas.values)
     )
 
diff --git a/dask/dataframe/tests/test_utils_dataframe.py b/dask/dataframe/tests/test_utils_dataframe.py
index 764a18251..103cc1b9f 100644
--- a/dask/dataframe/tests/test_utils_dataframe.py
+++ b/dask/dataframe/tests/test_utils_dataframe.py
@@ -2,8 +2,8 @@ import re
 
 import numpy as np
 import pandas as pd
-import pandas.util.testing as tm
 import dask.dataframe as dd
+from dask.dataframe._compat import tm
 from dask.dataframe.core import apply_and_enforce
 from dask.dataframe.utils import (
     shard_df_on_index,
diff --git a/dask/tests/test_base.py b/dask/tests/test_base.py
index c6b2ddffd..7f2f17cb0 100644
--- a/dask/tests/test_base.py
+++ b/dask/tests/test_base.py
@@ -617,8 +617,8 @@ def test_compute_dataframe():
     ddf1 = ddf.a + 1
     ddf2 = ddf.a + ddf.b
     out1, out2 = compute(ddf1, ddf2)
-    pd.util.testing.assert_series_equal(out1, df.a + 1)
-    pd.util.testing.assert_series_equal(out2, df.a + df.b)
+    pd.testing.assert_series_equal(out1, df.a + 1)
+    pd.testing.assert_series_equal(out2, df.a + df.b)
 
 
 @pytest.mark.skipif("not dd or not da")
@@ -629,7 +629,7 @@ def test_compute_array_dataframe():
     ddf = dd.from_pandas(df, npartitions=2).a + 2
     arr_out, df_out = compute(darr, ddf)
     assert np.allclose(arr_out, arr + 1)
-    pd.util.testing.assert_series_equal(df_out, df.a + 2)
+    dd._compat.tm.assert_series_equal(df_out, df.a + 2)
 
 
 @pytest.mark.skipif("not dd")
diff --git a/dask/tests/test_distributed.py b/dask/tests/test_distributed.py
index 4bd3a25d9..2ad52aa82 100644
--- a/dask/tests/test_distributed.py
+++ b/dask/tests/test_distributed.py
@@ -136,8 +136,12 @@ def test_to_hdf_distributed(c):
     ],
 )
 def test_to_hdf_scheduler_distributed(npartitions, c):
+    dd = pytest.importorskip("dask.dataframe")
     from ..dataframe.io.tests.test_hdf import test_to_hdf_schedulers
 
+    if dd._compat.PANDAS_GT_100:
+        pytest.skip("https://github.com/pandas-dev/pandas/issues/30962")
+
     test_to_hdf_schedulers(None, npartitions)
 
 
diff --git a/dask/tests/test_order.py b/dask/tests/test_order.py
index cef23e0f1..98e450f48 100644
--- a/dask/tests/test_order.py
+++ b/dask/tests/test_order.py
@@ -53,9 +53,7 @@ def test_avoid_broker_nodes(abcde):
         (b, 1): (f, (a, 1)),
         (b, 2): (f, (a, 1)),
     }
-
     o = order(dsk)
-
     assert o[(a, 0)] < o[(a, 1)]
 
     # Switch name of 0, 1 to ensure that this isn't due to string comparison
@@ -66,11 +64,20 @@ def test_avoid_broker_nodes(abcde):
         (b, 1): (f, (a, 0)),
         (b, 2): (f, (a, 0)),
     }
-
     o = order(dsk)
-
     assert o[(a, 0)] > o[(a, 1)]
 
+    # Switch name of 0, 1 for "b"s too
+    dsk = {
+        (a, 0): (f,),
+        (a, 1): (f,),
+        (b, 1): (f, (a, 0)),
+        (b, 0): (f, (a, 1)),
+        (b, 2): (f, (a, 1)),
+    }
+    o = order(dsk)
+    assert o[(a, 0)] < o[(a, 1)]
+
 
 def test_base_of_reduce_preferred(abcde):
     r"""
@@ -168,11 +175,10 @@ def test_avoid_upwards_branching_complex(abcde):
     }
 
     o = order(dsk)
-
     assert o[(c, 1)] < o[(b, 1)]
+    assert abs(o[(d, 2)] - o[(d, 3)]) == 1
 
 
-@pytest.mark.xfail(reason="this case is ambiguous", strict=False)
 def test_deep_bases_win_over_dependents(abcde):
     r"""
     It's not clear who should run first, e or d
@@ -181,6 +187,8 @@ def test_deep_bases_win_over_dependents(abcde):
     2.  e is nicer (hypothetically) because it will be sooner released
         (though in this case we need d to run first regardless)
 
+    Regardless of e or d first, we should run b before c.
+
             a
           / | \   .
          b  c |
@@ -191,8 +199,8 @@ def test_deep_bases_win_over_dependents(abcde):
     dsk = {a: (f, b, c, d), b: (f, d, e), c: (f, d), d: 1, e: 2}
 
     o = order(dsk)
-    assert o[e] < o[d]
-    assert o[d] < o[b] or o[d] < o[c]
+    assert o[e] < o[d]  # ambiguous, but this is what we currently expect
+    assert o[b] < o[c]
 
 
 def test_prefer_deep(abcde):
@@ -219,7 +227,6 @@ def test_stacklimit(abcde):
     ndependencies(dependencies, dependents)
 
 
-@pytest.mark.xfail(reason="Can't please 'em all")
 def test_break_ties_by_str(abcde):
     a, b, c, d, e = abcde
     dsk = {("x", i): (inc, i) for i in range(10)}
@@ -227,8 +234,8 @@ def test_break_ties_by_str(abcde):
     dsk["y"] = list(x_keys)
 
     o = order(dsk)
-    expected = {"y": 0}
-    expected.update({k: i + 1 for i, k in enumerate(x_keys)})
+    expected = {"y": 10}
+    expected.update({k: i for i, k in enumerate(x_keys)})
 
     assert o == expected
 
@@ -494,6 +501,7 @@ def test_prefer_short_ancestor(abcde):
     }
     o = order(dsk)
 
+    assert o[(a, 0)] < o[(a, 1)]
     assert o[(b, 0)] < o[(b, 1)]
     assert o[(b, 0)] < o[(c, 2)]
     assert o[(c, 1)] < o[(c, 2)]
@@ -535,3 +543,116 @@ def test_map_overlap(abcde):
     o = order(dsk)
 
     assert o[(b, 1)] < o[(e, 5)] or o[(b, 5)] < o[(e, 1)]
+
+
+def test_use_structure_not_keys(abcde):
+    """ See https://github.com/dask/dask/issues/5584#issuecomment-554963958
+
+    We were using key names to infer structure, which could result in funny behavior.
+    """
+    a, b, _, _, _ = abcde
+    dsk = {
+        (a, 0): (f,),
+        (a, 1): (f,),
+        (a, 2): (f,),
+        (a, 3): (f,),
+        (a, 4): (f,),
+        (a, 5): (f,),
+        (a, 6): (f,),
+        (a, 7): (f,),
+        (a, 8): (f,),
+        (a, 9): (f,),
+        (b, 5): (f, (a, 2)),
+        (b, 7): (f, (a, 0), (a, 2)),
+        (b, 9): (f, (a, 7), (a, 0), (a, 2)),
+        (b, 1): (f, (a, 4), (a, 7), (a, 0)),
+        (b, 2): (f, (a, 9), (a, 4), (a, 7)),
+        (b, 4): (f, (a, 6), (a, 9), (a, 4)),
+        (b, 3): (f, (a, 5), (a, 6), (a, 9)),
+        (b, 8): (f, (a, 1), (a, 5), (a, 6)),
+        (b, 6): (f, (a, 8), (a, 1), (a, 5)),
+        (b, 0): (f, (a, 3), (a, 8), (a, 1)),
+    }
+    o = order(dsk)
+    As = sorted(val for (letter, _), val in o.items() if letter == a)
+    Bs = sorted(val for (letter, _), val in o.items() if letter == b)
+    assert Bs[0] in {1, 3}
+    if Bs[0] == 3:
+        assert As == [0, 1, 2, 4, 6, 8, 10, 12, 14, 16]
+        assert Bs == [3, 5, 7, 9, 11, 13, 15, 17, 18, 19]
+    else:
+        assert As == [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
+        assert Bs == [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
+
+
+def test_dont_run_all_dependents_too_early(abcde):
+    """ From https://github.com/dask/dask-ml/issues/206#issuecomment-395873372 """
+    a, b, c, d, e = abcde
+    depth = 10
+    dsk = {(a, 0): 0, (b, 0): 1, (c, 0): 2, (d, 0): (f, (a, 0), (b, 0), (c, 0))}
+    for i in range(1, depth):
+        dsk[(b, i)] = (f, (b, 0))
+        dsk[(c, i)] = (f, (c, 0))
+        dsk[(d, i)] = (f, (d, i - 1), (b, i), (c, i))
+    o = order(dsk)
+    expected = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
+    actual = sorted(v for (letter, num), v in o.items() if letter == d)
+    assert expected == actual
+
+
+def test_many_branches_use_ndependencies(abcde):
+    """ From https://github.com/dask/dask/pull/5646#issuecomment-562700533
+
+    Sometimes we need larger or wider DAGs to test behavior.  This test
+    ensures we choose the branch with more work twice in successtion.
+    This is important, because ``order`` may search along dependencies
+    and then along dependents.
+
+    """
+    a, b, c, d, e = abcde
+    dd = d + d
+    ee = e + e
+    dsk = {
+        (a, 0): 0,
+        (a, 1): (f, (a, 0)),
+        (a, 2): (f, (a, 1)),
+        (b, 1): (f, (a, 0)),
+        (b, 2): (f, (b, 1)),
+        (c, 1): (f, (a, 0)),  # most short and thin; should go last
+        (d, 1): (f, (a, 0)),
+        (d, 2): (f, (d, 1)),
+        (dd, 1): (f, (a, 0)),
+        (dd, 2): (f, (dd, 1)),
+        (dd, 3): (f, (d, 2), (dd, 2)),
+        (e, 1): (f, (a, 0)),
+        (e, 2): (f, (e, 1)),
+        (ee, 1): (f, (a, 0)),
+        (ee, 2): (f, (ee, 1)),
+        (ee, 3): (f, (e, 2), (ee, 2)),
+        (a, 3): (f, (a, 2), (b, 2), (c, 1), (dd, 3), (ee, 3)),
+    }
+    o = order(dsk)
+    # run all d's and e's first
+    expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    actual = sorted(v for (letter, _), v in o.items() if letter in {d, dd, e, ee})
+    assert actual == expected
+    assert o[(c, 1)] == o[(a, 3)] - 1
+
+
+def test_order_cycle():
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        dask.get({"a": (f, "a")}, "a")  # we encounter this in `get`
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        order({"a": (f, "a")})  # trivial self-loop
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        order({("a", 0): (f, ("a", 0))})  # non-string
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        order({"a": (f, "b"), "b": (f, "c"), "c": (f, "a")})  # non-trivial loop
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        order({"a": (f, "b"), "b": (f, "c"), "c": (f, "a", "d"), "d": 1})
+    with pytest.raises(RuntimeError, match="Cycle detected"):
+        order({"a": (f, "b"), "b": (f, "c"), "c": (f, "a", "d"), "d": (f, "b")})
+
+
+def test_order_empty():
+    assert order({}) == {}

pip install -e .[complete]
parse_log_pytest
pytest
pytest
apt-get update apt-get install -y gcc
3.7
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
attrs @ file:///croot/attrs_1668696182826/work
bokeh==2.4.3
certifi @ file:///croot/certifi_1671487769961/work/certifi
click==8.1.8
cloudpickle==2.2.1
-e git+https://github.com/dask/dask.git@03a75ca4a7a6afd3bf7ee9ace1ce78c287545bad#egg=dask
distributed==2.30.1
flit_core @ file:///opt/conda/conda-bld/flit-core_1644941570762/work/source/flit_core
fsspec==2023.1.0
HeapDict==1.0.1
importlib-metadata @ file:///tmp/build/80754af9/importlib-metadata_1648562407465/work
iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
Jinja2==3.1.6
locket==1.0.0
MarkupSafe==2.1.5
msgpack==1.0.5
numpy==1.21.6
packaging @ file:///croot/packaging_1671697413597/work
pandas==1.3.5
partd==1.4.1
Pillow==9.5.0
pluggy @ file:///tmp/build/80754af9/pluggy_1648042572264/work
psutil==7.0.0
py @ file:///opt/conda/conda-bld/py_1644396412707/work
pytest==7.1.2
python-dateutil==2.9.0.post0
pytz==2025.2
PyYAML==6.0.1
six==1.17.0
sortedcontainers==2.4.0
tblib==2.0.0
tomli @ file:///opt/conda/conda-bld/tomli_1657175507142/work
toolz==0.12.1
tornado==6.2
typing_extensions @ file:///croot/typing_extensions_1669924550328/work
zict==2.2.0
zipp @ file:///croot/zipp_1672387121353/work

name: dask
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - attrs=22.1.0=py37h06a4308_0
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2022.12.7=py37h06a4308_0
  - flit-core=3.6.0=pyhd3eb1b0_0
  - importlib-metadata=4.11.3=py37h06a4308_0
  - importlib_metadata=4.11.3=hd3eb1b0_0
  - iniconfig=1.1.1=pyhd3eb1b0_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - packaging=22.0=py37h06a4308_0
  - pip=22.3.1=py37h06a4308_0
  - pluggy=1.0.0=py37h06a4308_1
  - py=1.11.0=pyhd3eb1b0_0
  - pytest=7.1.2=py37h06a4308_0
  - python=3.7.16=h7a1cb2a_0
  - readline=8.2=h5eee18b_0
  - setuptools=65.6.3=py37h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tomli=2.0.1=py37h06a4308_0
  - typing_extensions=4.4.0=py37h06a4308_0
  - wheel=0.38.4=py37h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - zipp=3.11.0=py37h06a4308_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - bokeh==2.4.3
      - click==8.1.8
      - cloudpickle==2.2.1
      - distributed==2.30.1
      - fsspec==2023.1.0
      - heapdict==1.0.1
      - jinja2==3.1.6
      - locket==1.0.0
      - markupsafe==2.1.5
      - msgpack==1.0.5
      - numpy==1.21.6
      - pandas==1.3.5
      - partd==1.4.1
      - pillow==9.5.0
      - psutil==7.0.0
      - python-dateutil==2.9.0.post0
      - pytz==2025.2
      - pyyaml==6.0.1
      - six==1.17.0
      - sortedcontainers==2.4.0
      - tblib==2.0.0
      - toolz==0.12.1
      - tornado==6.2
      - zict==2.2.0
prefix: /opt/conda/envs/dask

dask/array/tests/test_array_core.py::test_getem dask/array/tests/test_array_core.py::test_top dask/array/tests/test_array_core.py::test_top_supports_broadcasting_rules dask/array/tests/test_array_core.py::test_top_literals dask/array/tests/test_array_core.py::test_blockwise_literals dask/array/tests/test_array_core.py::test_concatenate3_on_scalars dask/array/tests/test_array_core.py::test_chunked_dot_product dask/array/tests/test_array_core.py::test_chunked_transpose_plus_one dask/array/tests/test_array_core.py::test_broadcast_dimensions_works_with_singleton_dimensions dask/array/tests/test_array_core.py::test_broadcast_dimensions dask/array/tests/test_array_core.py::test_Array dask/array/tests/test_array_core.py::test_uneven_chunks dask/array/tests/test_array_core.py::test_numblocks_suppoorts_singleton_block_dims dask/array/tests/test_array_core.py::test_keys dask/array/tests/test_array_core.py::test_Array_computation dask/array/tests/test_array_core.py::test_stack dask/array/tests/test_array_core.py::test_stack_zero_size dask/array/tests/test_array_core.py::test_short_stack dask/array/tests/test_array_core.py::test_stack_scalars dask/array/tests/test_array_core.py::test_stack_promote_type dask/array/tests/test_array_core.py::test_stack_rechunk dask/array/tests/test_array_core.py::test_concatenate dask/array/tests/test_array_core.py::test_concatenate_types[dtypes0] dask/array/tests/test_array_core.py::test_concatenate_types[dtypes1] dask/array/tests/test_array_core.py::test_concatenate_unknown_axes dask/array/tests/test_array_core.py::test_concatenate_rechunk dask/array/tests/test_array_core.py::test_concatenate_fixlen_strings dask/array/tests/test_array_core.py::test_concatenate_zero_size dask/array/tests/test_array_core.py::test_block_simple_row_wise dask/array/tests/test_array_core.py::test_block_simple_column_wise dask/array/tests/test_array_core.py::test_block_with_1d_arrays_row_wise dask/array/tests/test_array_core.py::test_block_with_1d_arrays_multiple_rows dask/array/tests/test_array_core.py::test_block_with_1d_arrays_column_wise dask/array/tests/test_array_core.py::test_block_mixed_1d_and_2d dask/array/tests/test_array_core.py::test_block_complicated dask/array/tests/test_array_core.py::test_block_nested dask/array/tests/test_array_core.py::test_block_3d dask/array/tests/test_array_core.py::test_block_with_mismatched_shape dask/array/tests/test_array_core.py::test_block_no_lists dask/array/tests/test_array_core.py::test_block_invalid_nesting dask/array/tests/test_array_core.py::test_block_empty_lists dask/array/tests/test_array_core.py::test_block_tuple dask/array/tests/test_array_core.py::test_broadcast_shapes dask/array/tests/test_array_core.py::test_elemwise_on_scalars dask/array/tests/test_array_core.py::test_elemwise_with_ndarrays dask/array/tests/test_array_core.py::test_elemwise_differently_chunked dask/array/tests/test_array_core.py::test_elemwise_dtype dask/array/tests/test_array_core.py::test_operators dask/array/tests/test_array_core.py::test_operator_dtype_promotion dask/array/tests/test_array_core.py::test_field_access dask/array/tests/test_array_core.py::test_field_access_with_shape dask/array/tests/test_array_core.py::test_matmul dask/array/tests/test_array_core.py::test_matmul_array_ufunc dask/array/tests/test_array_core.py::test_T dask/array/tests/test_array_core.py::test_broadcast_to dask/array/tests/test_array_core.py::test_broadcast_to_array dask/array/tests/test_array_core.py::test_broadcast_to_scalar dask/array/tests/test_array_core.py::test_broadcast_to_chunks dask/array/tests/test_array_core.py::test_broadcast_arrays dask/array/tests/test_array_core.py::test_broadcast_arrays_uneven_chunks dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape0-v_shape0] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape1-v_shape1] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape2-v_shape2] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape3-v_shape3] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape4-v_shape4] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape5-v_shape5] dask/array/tests/test_array_core.py::test_broadcast_operator[u_shape6-v_shape6] dask/array/tests/test_array_core.py::test_reshape[original_shape0-new_shape0-chunks0] dask/array/tests/test_array_core.py::test_reshape[original_shape1-new_shape1-5] dask/array/tests/test_array_core.py::test_reshape[original_shape2-new_shape2-5] dask/array/tests/test_array_core.py::test_reshape[original_shape3-new_shape3-12] dask/array/tests/test_array_core.py::test_reshape[original_shape4-new_shape4-12] dask/array/tests/test_array_core.py::test_reshape[original_shape5-new_shape5-chunks5] dask/array/tests/test_array_core.py::test_reshape[original_shape6-new_shape6-4] dask/array/tests/test_array_core.py::test_reshape[original_shape7-new_shape7-4] dask/array/tests/test_array_core.py::test_reshape[original_shape8-new_shape8-4] dask/array/tests/test_array_core.py::test_reshape[original_shape9-new_shape9-2] dask/array/tests/test_array_core.py::test_reshape[original_shape10-new_shape10-2] dask/array/tests/test_array_core.py::test_reshape[original_shape11-new_shape11-2] dask/array/tests/test_array_core.py::test_reshape[original_shape12-new_shape12-2] dask/array/tests/test_array_core.py::test_reshape[original_shape13-new_shape13-2] dask/array/tests/test_array_core.py::test_reshape[original_shape14-new_shape14-2] dask/array/tests/test_array_core.py::test_reshape[original_shape15-new_shape15-2] dask/array/tests/test_array_core.py::test_reshape[original_shape16-new_shape16-chunks16] dask/array/tests/test_array_core.py::test_reshape[original_shape17-new_shape17-3] dask/array/tests/test_array_core.py::test_reshape[original_shape18-new_shape18-4] dask/array/tests/test_array_core.py::test_reshape[original_shape19-new_shape19-chunks19] dask/array/tests/test_array_core.py::test_reshape[original_shape20-new_shape20-1] dask/array/tests/test_array_core.py::test_reshape[original_shape21-new_shape21-1] dask/array/tests/test_array_core.py::test_reshape[original_shape22-new_shape22-24] dask/array/tests/test_array_core.py::test_reshape[original_shape23-new_shape23-6] dask/array/tests/test_array_core.py::test_reshape[original_shape24-new_shape24-6] dask/array/tests/test_array_core.py::test_reshape[original_shape25-new_shape25-6] dask/array/tests/test_array_core.py::test_reshape[original_shape26-new_shape26-chunks26] dask/array/tests/test_array_core.py::test_reshape[original_shape27-new_shape27-chunks27] dask/array/tests/test_array_core.py::test_reshape[original_shape28-new_shape28-chunks28] dask/array/tests/test_array_core.py::test_reshape[original_shape29-new_shape29-chunks29] dask/array/tests/test_array_core.py::test_reshape[original_shape30-new_shape30-chunks30] dask/array/tests/test_array_core.py::test_reshape[original_shape31-new_shape31-chunks31] dask/array/tests/test_array_core.py::test_reshape[original_shape32-new_shape32-chunks32] dask/array/tests/test_array_core.py::test_reshape[original_shape33-new_shape33-chunks33] dask/array/tests/test_array_core.py::test_reshape[original_shape34-new_shape34-chunks34] dask/array/tests/test_array_core.py::test_reshape_exceptions dask/array/tests/test_array_core.py::test_reshape_splat dask/array/tests/test_array_core.py::test_reshape_fails_for_dask_only dask/array/tests/test_array_core.py::test_reshape_unknown_dimensions dask/array/tests/test_array_core.py::test_full dask/array/tests/test_array_core.py::test_map_blocks dask/array/tests/test_array_core.py::test_map_blocks2 dask/array/tests/test_array_core.py::test_map_blocks_block_info dask/array/tests/test_array_core.py::test_map_blocks_block_info_with_new_axis dask/array/tests/test_array_core.py::test_map_blocks_block_info_with_drop_axis dask/array/tests/test_array_core.py::test_map_blocks_block_info_with_broadcast dask/array/tests/test_array_core.py::test_map_blocks_with_constants dask/array/tests/test_array_core.py::test_map_blocks_with_kwargs dask/array/tests/test_array_core.py::test_map_blocks_with_chunks dask/array/tests/test_array_core.py::test_map_blocks_dtype_inference dask/array/tests/test_array_core.py::test_map_blocks_infer_newaxis dask/array/tests/test_array_core.py::test_map_blocks_no_array_args dask/array/tests/test_array_core.py::test_repr dask/array/tests/test_array_core.py::test_slicing_with_ellipsis dask/array/tests/test_array_core.py::test_slicing_with_ndarray dask/array/tests/test_array_core.py::test_slicing_flexible_type dask/array/tests/test_array_core.py::test_dtype dask/array/tests/test_array_core.py::test_blockdims_from_blockshape dask/array/tests/test_array_core.py::test_coerce dask/array/tests/test_array_core.py::test_bool dask/array/tests/test_array_core.py::test_store_kwargs dask/array/tests/test_array_core.py::test_store_delayed_target dask/array/tests/test_array_core.py::test_store dask/array/tests/test_array_core.py::test_store_regions dask/array/tests/test_array_core.py::test_store_compute_false dask/array/tests/test_array_core.py::test_store_nocompute_regions dask/array/tests/test_array_core.py::test_store_locks dask/array/tests/test_array_core.py::test_store_method_return dask/array/tests/test_array_core.py::test_to_dask_dataframe dask/array/tests/test_array_core.py::test_np_array_with_zero_dimensions dask/array/tests/test_array_core.py::test_dtype_complex dask/array/tests/test_array_core.py::test_astype dask/array/tests/test_array_core.py::test_arithmetic dask/array/tests/test_array_core.py::test_elemwise_consistent_names dask/array/tests/test_array_core.py::test_optimize dask/array/tests/test_array_core.py::test_slicing_with_non_ndarrays dask/array/tests/test_array_core.py::test_getter dask/array/tests/test_array_core.py::test_size dask/array/tests/test_array_core.py::test_nbytes dask/array/tests/test_array_core.py::test_itemsize dask/array/tests/test_array_core.py::test_Array_normalizes_dtype dask/array/tests/test_array_core.py::test_from_array_with_lock dask/array/tests/test_array_core.py::test_from_array_tasks_always_call_getter[x0-chunks0] dask/array/tests/test_array_core.py::test_from_array_tasks_always_call_getter[x1--1] dask/array/tests/test_array_core.py::test_from_array_tasks_always_call_getter[x2-1] dask/array/tests/test_array_core.py::test_from_array_tasks_always_call_getter[x3-1] dask/array/tests/test_array_core.py::test_from_array_ndarray_onechunk dask/array/tests/test_array_core.py::test_from_array_ndarray_getitem dask/array/tests/test_array_core.py::test_from_array_list[x0] dask/array/tests/test_array_core.py::test_from_array_list[x1] dask/array/tests/test_array_core.py::test_from_array_list[x2] dask/array/tests/test_array_core.py::test_from_array_scalar[int0] dask/array/tests/test_array_core.py::test_from_array_scalar[float] dask/array/tests/test_array_core.py::test_from_array_scalar[complex] dask/array/tests/test_array_core.py::test_from_array_scalar[int1] dask/array/tests/test_array_core.py::test_from_array_scalar[bool] dask/array/tests/test_array_core.py::test_from_array_scalar[bytes] dask/array/tests/test_array_core.py::test_from_array_scalar[str] dask/array/tests/test_array_core.py::test_from_array_scalar[bool_] dask/array/tests/test_array_core.py::test_from_array_scalar[complex64] dask/array/tests/test_array_core.py::test_from_array_scalar[complex128] dask/array/tests/test_array_core.py::test_from_array_scalar[complex256] dask/array/tests/test_array_core.py::test_from_array_scalar[float16] dask/array/tests/test_array_core.py::test_from_array_scalar[float32] dask/array/tests/test_array_core.py::test_from_array_scalar[float64] dask/array/tests/test_array_core.py::test_from_array_scalar[float128] dask/array/tests/test_array_core.py::test_from_array_scalar[int8] dask/array/tests/test_array_core.py::test_from_array_scalar[int16] dask/array/tests/test_array_core.py::test_from_array_scalar[int32] dask/array/tests/test_array_core.py::test_from_array_scalar[int64] dask/array/tests/test_array_core.py::test_from_array_scalar[longlong] dask/array/tests/test_array_core.py::test_from_array_scalar[timedelta64] dask/array/tests/test_array_core.py::test_from_array_scalar[datetime64] dask/array/tests/test_array_core.py::test_from_array_scalar[object_] dask/array/tests/test_array_core.py::test_from_array_scalar[bytes_] dask/array/tests/test_array_core.py::test_from_array_scalar[str_] dask/array/tests/test_array_core.py::test_from_array_scalar[uint8] dask/array/tests/test_array_core.py::test_from_array_scalar[uint16] dask/array/tests/test_array_core.py::test_from_array_scalar[uint32] dask/array/tests/test_array_core.py::test_from_array_scalar[uint64] dask/array/tests/test_array_core.py::test_from_array_scalar[ulonglong] dask/array/tests/test_array_core.py::test_from_array_scalar[void] dask/array/tests/test_array_core.py::test_from_array_no_asarray[True-ndarray] dask/array/tests/test_array_core.py::test_from_array_no_asarray[False-matrix] dask/array/tests/test_array_core.py::test_from_array_getitem dask/array/tests/test_array_core.py::test_from_array_minus_one dask/array/tests/test_array_core.py::test_from_array_copy dask/array/tests/test_array_core.py::test_from_array_dask_array dask/array/tests/test_array_core.py::test_asarray dask/array/tests/test_array_core.py::test_asarray_dask_dataframe dask/array/tests/test_array_core.py::test_asarray_chunks dask/array/tests/test_array_core.py::test_asanyarray dask/array/tests/test_array_core.py::test_asanyarray_dataframe dask/array/tests/test_array_core.py::test_asanyarray_datetime64 dask/array/tests/test_array_core.py::test_from_func dask/array/tests/test_array_core.py::test_concatenate3_2 dask/array/tests/test_array_core.py::test_map_blocks3 dask/array/tests/test_array_core.py::test_from_array_with_missing_chunks dask/array/tests/test_array_core.py::test_normalize_chunks dask/array/tests/test_array_core.py::test_align_chunks_to_previous_chunks dask/array/tests/test_array_core.py::test_raise_on_no_chunks dask/array/tests/test_array_core.py::test_chunks_is_immutable dask/array/tests/test_array_core.py::test_raise_on_bad_kwargs dask/array/tests/test_array_core.py::test_long_slice dask/array/tests/test_array_core.py::test_ellipsis_slicing dask/array/tests/test_array_core.py::test_point_slicing dask/array/tests/test_array_core.py::test_point_slicing_with_full_slice dask/array/tests/test_array_core.py::test_slice_with_floats dask/array/tests/test_array_core.py::test_slice_with_integer_types dask/array/tests/test_array_core.py::test_index_with_integer_types dask/array/tests/test_array_core.py::test_vindex_basic dask/array/tests/test_array_core.py::test_vindex_nd dask/array/tests/test_array_core.py::test_vindex_negative dask/array/tests/test_array_core.py::test_vindex_errors dask/array/tests/test_array_core.py::test_vindex_merge dask/array/tests/test_array_core.py::test_vindex_identity dask/array/tests/test_array_core.py::test_empty_array dask/array/tests/test_array_core.py::test_memmap dask/array/tests/test_array_core.py::test_to_npy_stack dask/array/tests/test_array_core.py::test_view dask/array/tests/test_array_core.py::test_view_fortran dask/array/tests/test_array_core.py::test_map_blocks_with_changed_dimension dask/array/tests/test_array_core.py::test_map_blocks_with_changed_dimension_and_broadcast_chunks dask/array/tests/test_array_core.py::test_broadcast_chunks dask/array/tests/test_array_core.py::test_chunks_error dask/array/tests/test_array_core.py::test_array_compute_forward_kwargs dask/array/tests/test_array_core.py::test_dont_fuse_outputs dask/array/tests/test_array_core.py::test_dont_dealias_outputs dask/array/tests/test_array_core.py::test_timedelta_op dask/array/tests/test_array_core.py::test_to_delayed dask/array/tests/test_array_core.py::test_to_delayed_optimize_graph dask/array/tests/test_array_core.py::test_cumulative dask/array/tests/test_array_core.py::test_from_delayed dask/array/tests/test_array_core.py::test_from_delayed_meta dask/array/tests/test_array_core.py::test_A_property dask/array/tests/test_array_core.py::test_copy_mutate dask/array/tests/test_array_core.py::test_npartitions dask/array/tests/test_array_core.py::test_astype_gh1151 dask/array/tests/test_array_core.py::test_elemwise_name dask/array/tests/test_array_core.py::test_map_blocks_name dask/array/tests/test_array_core.py::test_from_array_names dask/array/tests/test_array_core.py::test_array_picklable dask/array/tests/test_array_core.py::test_from_array_raises_on_bad_chunks dask/array/tests/test_array_core.py::test_concatenate_axes dask/array/tests/test_array_core.py::test_blockwise_concatenate dask/array/tests/test_array_core.py::test_common_blockdim dask/array/tests/test_array_core.py::test_uneven_chunks_that_fit_neatly dask/array/tests/test_array_core.py::test_elemwise_uneven_chunks dask/array/tests/test_array_core.py::test_uneven_chunks_blockwise dask/array/tests/test_array_core.py::test_warn_bad_rechunking dask/array/tests/test_array_core.py::test_concatenate_stack_dont_warn dask/array/tests/test_array_core.py::test_map_blocks_delayed dask/array/tests/test_array_core.py::test_no_chunks dask/array/tests/test_array_core.py::test_no_chunks_2d dask/array/tests/test_array_core.py::test_no_chunks_yes_chunks dask/array/tests/test_array_core.py::test_raise_informative_errors_no_chunks dask/array/tests/test_array_core.py::test_no_chunks_slicing_2d dask/array/tests/test_array_core.py::test_index_array_with_array_1d dask/array/tests/test_array_core.py::test_index_array_with_array_2d dask/array/tests/test_array_core.py::test_setitem_1d dask/array/tests/test_array_core.py::test_setitem_2d dask/array/tests/test_array_core.py::test_setitem_errs dask/array/tests/test_array_core.py::test_zero_slice_dtypes dask/array/tests/test_array_core.py::test_zero_sized_array_rechunk dask/array/tests/test_array_core.py::test_blockwise_zero_shape dask/array/tests/test_array_core.py::test_blockwise_zero_shape_new_axes dask/array/tests/test_array_core.py::test_broadcast_against_zero_shape dask/array/tests/test_array_core.py::test_from_array_name dask/array/tests/test_array_core.py::test_concatenate_errs dask/array/tests/test_array_core.py::test_stack_errs dask/array/tests/test_array_core.py::test_blockwise_with_numpy_arrays dask/array/tests/test_array_core.py::test_elemwise_with_lists[other0-100] dask/array/tests/test_array_core.py::test_elemwise_with_lists[other0-6] dask/array/tests/test_array_core.py::test_elemwise_with_lists[other1-100] dask/array/tests/test_array_core.py::test_elemwise_with_lists[other1-6] dask/array/tests/test_array_core.py::test_elemwise_with_lists[other2-100] dask/array/tests/test_array_core.py::test_elemwise_with_lists[other2-6] dask/array/tests/test_array_core.py::test_constructor_plugin dask/array/tests/test_array_core.py::test_no_warnings_on_metadata dask/array/tests/test_array_core.py::test_delayed_array_key_hygeine dask/array/tests/test_array_core.py::test_empty_chunks_in_array_len dask/array/tests/test_array_core.py::test_meta[None] dask/array/tests/test_array_core.py::test_meta[dtype1] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[100-10-expected0] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[20-10-expected1] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[20-5-expected2] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[24-5-expected3] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[23-5-expected4] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_1d[1000-167-expected5] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_2d[shape0-chunks0-20-expected0] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_2d[shape1-chunks1-20-expected1] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_2d[shape2-auto-10-expected2] dask/array/tests/test_array_core.py::test_normalize_chunks_auto_3d dask/array/tests/test_array_core.py::test_constructors_chunks_dict dask/array/tests/test_array_core.py::test_from_array_chunks_dict dask/array/tests/test_array_core.py::test_normalize_chunks_object_dtype[object] dask/array/tests/test_array_core.py::test_normalize_chunks_object_dtype[dtype1] dask/array/tests/test_array_core.py::test_normalize_chunks_tuples_of_tuples dask/array/tests/test_array_core.py::test_normalize_chunks_nan dask/array/tests/test_array_core.py::test_regular_chunks[data0] dask/array/tests/test_array_core.py::test_regular_chunks[data1] dask/array/tests/test_array_core.py::test_regular_chunks[data2] dask/array/tests/test_array_core.py::test_regular_chunks[data3] dask/array/tests/test_array_core.py::test_regular_chunks[data4] dask/array/tests/test_array_core.py::test_regular_chunks[data5] dask/array/tests/test_array_core.py::test_regular_chunks[data6] dask/array/tests/test_array_core.py::test_regular_chunks[data7] dask/array/tests/test_array_core.py::test_blocks_indexer dask/array/tests/test_array_core.py::test_partitions_indexer dask/array/tests/test_array_core.py::test_3851 dask/array/tests/test_array_core.py::test_3925 dask/array/tests/test_array_core.py::test_map_blocks_large_inputs_delayed dask/array/tests/test_array_core.py::test_blockwise_large_inputs_delayed dask/array/tests/test_array_core.py::test_slice_reversed dask/array/tests/test_array_core.py::test_map_blocks_chunks dask/array/tests/test_array_core.py::test_nbytes_auto dask/array/tests/test_array_core.py::test_compute_chunk_sizes dask/array/tests/test_array_core.py::test_compute_chunk_sizes_2d_array dask/array/tests/test_array_core.py::test_compute_chunk_sizes_3d_array dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_rechunk dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_to_svg dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_concatenate dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_reduction dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_reshape dask/array/tests/test_array_core.py::test_compute_chunk_sizes_warning_fixes_slicing dask/array/tests/test_array_core.py::test_rechunk_auto dask/dataframe/io/tests/test_csv.py::test_pandas_read_text[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_kwargs[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_kwargs[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_kwargs[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_dtype_coercion[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_dtype_coercion[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_dtype_coercion[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_with_header[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_with_header[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_pandas_read_text_with_header[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_simple[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_simple[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_simple[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_kwargs[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_kwargs[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_kwargs[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_blocked[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_blocked[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_text_blocks_to_pandas_blocked[read_fwf-files2] dask/dataframe/io/tests/test_csv.py::test_skiprows[read_csv-read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_skiprows[read_table-read_table-files1] dask/dataframe/io/tests/test_csv.py::test_skiprows_as_list[read_csv-read_csv-files0-str, dask/dataframe/io/tests/test_csv.py::test_skiprows_as_list[read_table-read_table-files1-str\t dask/dataframe/io/tests/test_csv.py::test_enforce_dtypes[read_csv-blocks0] dask/dataframe/io/tests/test_csv.py::test_enforce_dtypes[read_table-blocks1] dask/dataframe/io/tests/test_csv.py::test_enforce_columns[read_csv-blocks0] dask/dataframe/io/tests/test_csv.py::test_enforce_columns[read_table-blocks1] dask/dataframe/io/tests/test_csv.py::test_read_csv[read_csv-read_csv-name,amount\nAlice,100\nBob,-200\nCharlie,300\nDennis,400\nEdith,-500\nFrank,600\nAlice,200\nFrank,-200\nBob,600\nAlice,400\nFrank,200\nAlice,300\nEdith,600-,] dask/dataframe/io/tests/test_csv.py::test_read_csv[read_table-read_table-name\tamount\nAlice\t100\nBob\t-200\nCharlie\t300\nDennis\t400\nEdith\t-500\nFrank\t600\nAlice\t200\nFrank\t-200\nBob\t600\nAlice\t400\nFrank\t200\nAlice\t300\nEdith\t600-\t] dask/dataframe/io/tests/test_csv.py::test_read_csv[read_table-read_table-name dask/dataframe/io/tests/test_csv.py::test_read_csv_large_skiprows[read_csv-read_csv-name,amount\nAlice,100\nBob,-200\nCharlie,300\nDennis,400\nEdith,-500\nFrank,600\nAlice,200\nFrank,-200\nBob,600\nAlice,400\nFrank,200\nAlice,300\nEdith,600-7] dask/dataframe/io/tests/test_csv.py::test_read_csv_large_skiprows[read_table-read_table-name\tamount\nAlice\t100\nBob\t-200\nCharlie\t300\nDennis\t400\nEdith\t-500\nFrank\t600\nAlice\t200\nFrank\t-200\nBob\t600\nAlice\t400\nFrank\t200\nAlice\t300\nEdith\t600-skip1] dask/dataframe/io/tests/test_csv.py::test_read_csv_skiprows_only_in_first_partition[read_csv-read_csv-name,amount\nAlice,100\nBob,-200\nCharlie,300\nDennis,400\nEdith,-500\nFrank,600\nAlice,200\nFrank,-200\nBob,600\nAlice,400\nFrank,200\nAlice,300\nEdith,600-7] dask/dataframe/io/tests/test_csv.py::test_read_csv_skiprows_only_in_first_partition[read_table-read_table-name\tamount\nAlice\t100\nBob\t-200\nCharlie\t300\nDennis\t400\nEdith\t-500\nFrank\t600\nAlice\t200\nFrank\t-200\nBob\t600\nAlice\t400\nFrank\t200\nAlice\t300\nEdith\t600-skip1] dask/dataframe/io/tests/test_csv.py::test_read_csv_files[read_csv-read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_files[read_table-read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_files_list[read_csv-read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_files_list[read_table-read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_as_str[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_as_str[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_with_duplicate_name[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_with_duplicate_name[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_is_dtype_category[read_csv-files0] dask/dataframe/io/tests/test_csv.py::test_read_csv_include_path_column_is_dtype_category[read_table-files1] dask/dataframe/io/tests/test_csv.py::test_read_csv_index dask/dataframe/io/tests/test_csv.py::test_read_csv_skiprows_range dask/dataframe/io/tests/test_csv.py::test_usecols dask/dataframe/io/tests/test_csv.py::test_string_blocksize dask/dataframe/io/tests/test_csv.py::test_skipinitialspace dask/dataframe/io/tests/test_csv.py::test_consistent_dtypes dask/dataframe/io/tests/test_csv.py::test_consistent_dtypes_2 dask/dataframe/io/tests/test_csv.py::test_empty_csv_file dask/dataframe/io/tests/test_csv.py::test_read_csv_no_sample dask/dataframe/io/tests/test_csv.py::test_read_csv_sensitive_to_enforce dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[None-None] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[zip-None] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[bz2-None] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[gzip-None] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[xz-None] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[None-10] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[zip-10] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[bz2-10] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[gzip-10] dask/dataframe/io/tests/test_csv.py::test_read_csv_compression[xz-10] dask/dataframe/io/tests/test_csv.py::test_windows_line_terminator dask/dataframe/io/tests/test_csv.py::test_header_None dask/dataframe/io/tests/test_csv.py::test_auto_blocksize dask/dataframe/io/tests/test_csv.py::test_auto_blocksize_max64mb dask/dataframe/io/tests/test_csv.py::test_auto_blocksize_csv dask/dataframe/io/tests/test_csv.py::test_head_partial_line_fix dask/dataframe/io/tests/test_csv.py::test_read_csv_raises_on_no_files dask/dataframe/io/tests/test_csv.py::test_read_csv_has_deterministic_name dask/dataframe/io/tests/test_csv.py::test_multiple_read_csv_has_deterministic_name dask/dataframe/io/tests/test_csv.py::test_csv_with_integer_names dask/dataframe/io/tests/test_csv.py::test_late_dtypes dask/dataframe/io/tests/test_csv.py::test_assume_missing dask/dataframe/io/tests/test_csv.py::test_index_col dask/dataframe/io/tests/test_csv.py::test_read_csv_with_datetime_index_partitions_one dask/dataframe/io/tests/test_csv.py::test_read_csv_with_datetime_index_partitions_n dask/dataframe/io/tests/test_csv.py::test_encoding_gh601[utf-16-be] dask/dataframe/io/tests/test_csv.py::test_read_csv_header_issue_823 dask/dataframe/io/tests/test_csv.py::test_none_usecols dask/dataframe/io/tests/test_csv.py::test_parse_dates_multi_column dask/dataframe/io/tests/test_csv.py::test_read_csv_sep dask/dataframe/io/tests/test_csv.py::test_read_csv_slash_r dask/dataframe/io/tests/test_csv.py::test_read_csv_singleton_dtype dask/dataframe/io/tests/test_csv.py::test_robust_column_mismatch dask/dataframe/io/tests/test_csv.py::test_error_if_sample_is_too_small dask/dataframe/io/tests/test_csv.py::test_read_csv_names_not_none dask/dataframe/io/tests/test_csv.py::test_to_csv dask/dataframe/io/tests/test_csv.py::test_to_csv_multiple_files_cornercases dask/dataframe/io/tests/test_csv.py::test_to_single_csv dask/dataframe/io/tests/test_csv.py::test_to_single_csv_with_name_function dask/dataframe/io/tests/test_csv.py::test_to_single_csv_with_header_first_partition_only dask/dataframe/io/tests/test_csv.py::test_to_single_csv_gzip dask/dataframe/io/tests/test_csv.py::test_to_csv_simple dask/dataframe/io/tests/test_csv.py::test_to_csv_series dask/dataframe/io/tests/test_csv.py::test_to_csv_with_get dask/dataframe/io/tests/test_csv.py::test_to_csv_paths dask/dataframe/io/tests/test_csv.py::test_to_csv_header_empty_dataframe[False-] dask/dataframe/io/tests/test_csv.py::test_to_csv_header_empty_dataframe[True-x,y\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[False-False-a,1\n-d,4\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[True-False-x,y\n-x,y\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[False-True-a,1\n-d,4\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[True-True-x,y\n-d,4\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[header4-False-aa,bb\n-aa,bb\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_header[header5-True-aa,bb\n-d,4\n] dask/dataframe/io/tests/test_csv.py::test_to_csv_line_ending dask/dataframe/io/tests/test_demo.py::test_make_timeseries_no_args dask/dataframe/io/tests/test_demo.py::test_no_overlaps dask/dataframe/io/tests/test_demo.py::test_make_timeseries_keywords dask/dataframe/io/tests/test_demo.py::test_make_timeseries_fancy_keywords dask/dataframe/io/tests/test_io.py::test_meta_from_array dask/dataframe/io/tests/test_io.py::test_meta_from_1darray dask/dataframe/io/tests/test_io.py::test_meta_from_recarray dask/dataframe/io/tests/test_io.py::test_from_array dask/dataframe/io/tests/test_io.py::test_from_array_with_record_dtype dask/dataframe/io/tests/test_io.py::test_from_pandas_dataframe dask/dataframe/io/tests/test_io.py::test_from_pandas_small dask/dataframe/io/tests/test_io.py::test_from_pandas_npartitions_is_accurate[1] dask/dataframe/io/tests/test_io.py::test_from_pandas_npartitions_is_accurate[2] dask/dataframe/io/tests/test_io.py::test_from_pandas_npartitions_is_accurate[4] dask/dataframe/io/tests/test_io.py::test_from_pandas_npartitions_is_accurate[5] dask/dataframe/io/tests/test_io.py::test_from_pandas_series dask/dataframe/io/tests/test_io.py::test_from_pandas_non_sorted dask/dataframe/io/tests/test_io.py::test_from_pandas_single_row dask/dataframe/io/tests/test_io.py::test_from_pandas_with_datetime_index dask/dataframe/io/tests/test_io.py::test_DataFrame_from_dask_array dask/dataframe/io/tests/test_io.py::test_Series_from_dask_array dask/dataframe/io/tests/test_io.py::test_from_dask_array_index[True] dask/dataframe/io/tests/test_io.py::test_from_dask_array_index[False] dask/dataframe/io/tests/test_io.py::test_from_dask_array_index_raises dask/dataframe/io/tests/test_io.py::test_from_dask_array_compat_numpy_array dask/dataframe/io/tests/test_io.py::test_from_dask_array_compat_numpy_array_1d dask/dataframe/io/tests/test_io.py::test_from_dask_array_struct_dtype dask/dataframe/io/tests/test_io.py::test_from_dask_array_unknown_chunks dask/dataframe/io/tests/test_io.py::test_to_bag dask/dataframe/io/tests/test_io.py::test_to_records dask/dataframe/io/tests/test_io.py::test_to_records_with_lengths[lengths0] dask/dataframe/io/tests/test_io.py::test_to_records_with_lengths[True] dask/dataframe/io/tests/test_io.py::test_to_records_raises dask/dataframe/io/tests/test_io.py::test_from_delayed dask/dataframe/io/tests/test_io.py::test_from_delayed_misordered_meta dask/dataframe/io/tests/test_io.py::test_from_delayed_sorted dask/dataframe/io/tests/test_io.py::test_to_delayed dask/dataframe/io/tests/test_io.py::test_to_delayed_optimize_graph dask/dataframe/io/tests/test_io.py::test_from_dask_array_index_dtype dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata[pandas_metadata0] dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata[pandas_metadata1] dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata[pandas_metadata2] dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata_null_index dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata_duplicate_index_columns dask/dataframe/io/tests/test_parquet.py::test_parse_pandas_metadata_column_with_index_name dask/dataframe/io/tests/test_parquet.py::test_informative_error_messages dask/dataframe/io/tests/test_parquet.py::test_subgraph_getitem dask/dataframe/tests/test_accessors.py::test_register[Series-register_series_accessor] dask/dataframe/tests/test_accessors.py::test_register[DataFrame-register_dataframe_accessor] dask/dataframe/tests/test_accessors.py::test_register[Index-register_index_accessor] dask/dataframe/tests/test_accessors.py::test_accessor_works dask/dataframe/tests/test_accessors.py::test_dt_accessor dask/dataframe/tests/test_accessors.py::test_dt_accessor_not_available dask/dataframe/tests/test_accessors.py::test_str_accessor dask/dataframe/tests/test_accessors.py::test_str_accessor_not_available dask/dataframe/tests/test_accessors.py::test_str_accessor_getitem dask/dataframe/tests/test_accessors.py::test_str_accessor_extractall dask/dataframe/tests/test_accessors.py::test_str_accessor_cat dask/dataframe/tests/test_accessors.py::test_str_accessor_noexpand dask/dataframe/tests/test_accessors.py::test_str_accessor_expand dask/dataframe/tests/test_arithmetics_reduction.py::test_deterministic_arithmetic_names dask/dataframe/tests/test_arithmetics_reduction.py::test_scalar_arithmetics dask/dataframe/tests/test_arithmetics_reduction.py::test_scalar_arithmetics_with_dask_instances dask/dataframe/tests/test_arithmetics_reduction.py::test_frame_series_arithmetic_methods dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_timedelta[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_timedelta[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[sum-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[sum-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[sum-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[prod-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[prod-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[prod-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[min-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[min-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[min-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[max-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[max-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[max-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[mean-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[mean-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[mean-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[var-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[var-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[var-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[std-frame0-0-out0] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[std-frame1-1-out1] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_out[std-frame2-None-None] dask/dataframe/tests/test_arithmetics_reduction.py::test_allany[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_allany[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_deterministic_reduction_names[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_deterministic_reduction_names[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_reduction_series_invalid_axis dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_frame[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_frame[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_frame_nan[False] dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_frame_nan[2] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[lt] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[gt] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[le] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[ge] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[ne] dask/dataframe/tests/test_arithmetics_reduction.py::test_series_comparison_nan[eq] dask/dataframe/tests/test_arithmetics_reduction.py::test_sum_intna dask/dataframe/tests/test_arithmetics_reduction.py::test_divmod dask/dataframe/tests/test_categorical.py::test_concat_unions_categoricals dask/dataframe/tests/test_categorical.py::test_unknown_categoricals dask/dataframe/tests/test_categorical.py::test_is_categorical_dtype dask/dataframe/tests/test_categorical.py::test_categorical_set_index[disk] dask/dataframe/tests/test_categorical.py::test_categorical_set_index[tasks] dask/dataframe/tests/test_categorical.py::test_categorical_accessor_presence dask/dataframe/tests/test_categorical.py::test_categorize_nan dask/dataframe/tests/test_categorical.py::test_return_type_known_categories dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[categories-assert_array_index_eq-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[categories-assert_array_index_eq-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[categories-assert_array_index_eq-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[ordered-assert_eq-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[ordered-assert_eq-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[ordered-assert_eq-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[codes-assert_array_index_eq-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[codes-assert_array_index_eq-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_properties[codes-assert_array_index_eq-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[add_categories-kwargs0-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[add_categories-kwargs0-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[add_categories-kwargs0-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs1-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs1-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs1-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_unordered-kwargs2-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_unordered-kwargs2-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_unordered-kwargs2-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs3-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs3-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[as_ordered-kwargs3-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_categories-kwargs4-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_categories-kwargs4-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_categories-kwargs4-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[rename_categories-kwargs5-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[rename_categories-kwargs5-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[rename_categories-kwargs5-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[reorder_categories-kwargs6-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[reorder_categories-kwargs6-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[reorder_categories-kwargs6-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[set_categories-kwargs7-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[set_categories-kwargs7-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[set_categories-kwargs7-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_unused_categories-kwargs8-series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_unused_categories-kwargs8-series1] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_callable[remove_unused_categories-kwargs8-series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_categorical_empty dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_unknown_categories[series2] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_categorical_string_ops dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_categorical_non_string_raises dask/dataframe/tests/test_dataframe.py::test_dataframe_doc dask/dataframe/tests/test_dataframe.py::test_Dataframe dask/dataframe/tests/test_dataframe.py::test_head_tail dask/dataframe/tests/test_dataframe.py::test_head_npartitions dask/dataframe/tests/test_dataframe.py::test_head_npartitions_warn dask/dataframe/tests/test_dataframe.py::test_index_head dask/dataframe/tests/test_dataframe.py::test_Series dask/dataframe/tests/test_dataframe.py::test_Index dask/dataframe/tests/test_dataframe.py::test_Scalar dask/dataframe/tests/test_dataframe.py::test_scalar_raises dask/dataframe/tests/test_dataframe.py::test_attributes dask/dataframe/tests/test_dataframe.py::test_column_names dask/dataframe/tests/test_dataframe.py::test_index_names dask/dataframe/tests/test_dataframe.py::test_rename_columns dask/dataframe/tests/test_dataframe.py::test_rename_series dask/dataframe/tests/test_dataframe.py::test_rename_series_method dask/dataframe/tests/test_dataframe.py::test_rename_series_method_2 dask/dataframe/tests/test_dataframe.py::test_describe_numeric[dask-test_values1] dask/dataframe/tests/test_dataframe.py::test_describe[None-None-None-subset0] dask/dataframe/tests/test_dataframe.py::test_describe[None-None-None-subset2] dask/dataframe/tests/test_dataframe.py::test_describe_empty dask/dataframe/tests/test_dataframe.py::test_describe_for_possibly_unsorted_q dask/dataframe/tests/test_dataframe.py::test_cumulative dask/dataframe/tests/test_dataframe.py::test_cumulative_empty_partitions[func0] dask/dataframe/tests/test_dataframe.py::test_cumulative_empty_partitions[func1] dask/dataframe/tests/test_dataframe.py::test_dropna dask/dataframe/tests/test_dataframe.py::test_clip[2-5] dask/dataframe/tests/test_dataframe.py::test_clip[2.5-3.5] dask/dataframe/tests/test_dataframe.py::test_squeeze dask/dataframe/tests/test_dataframe.py::test_where_mask dask/dataframe/tests/test_dataframe.py::test_map_partitions_multi_argument dask/dataframe/tests/test_dataframe.py::test_map_partitions dask/dataframe/tests/test_dataframe.py::test_map_partitions_type dask/dataframe/tests/test_dataframe.py::test_map_partitions_names dask/dataframe/tests/test_dataframe.py::test_map_partitions_column_info dask/dataframe/tests/test_dataframe.py::test_map_partitions_method_names dask/dataframe/tests/test_dataframe.py::test_map_partitions_propagates_index_metadata dask/dataframe/tests/test_dataframe.py::test_metadata_inference_single_partition_aligned_args dask/dataframe/tests/test_dataframe.py::test_drop_duplicates dask/dataframe/tests/test_dataframe.py::test_drop_duplicates_subset dask/dataframe/tests/test_dataframe.py::test_get_partition dask/dataframe/tests/test_dataframe.py::test_ndim dask/dataframe/tests/test_dataframe.py::test_dtype dask/dataframe/tests/test_dataframe.py::test_value_counts dask/dataframe/tests/test_dataframe.py::test_unique dask/dataframe/tests/test_dataframe.py::test_isin dask/dataframe/tests/test_dataframe.py::test_len dask/dataframe/tests/test_dataframe.py::test_size dask/dataframe/tests/test_dataframe.py::test_shape dask/dataframe/tests/test_dataframe.py::test_nbytes dask/dataframe/tests/test_dataframe.py::test_quantile[dask-expected1] dask/dataframe/tests/test_dataframe.py::test_quantile_missing[dask] dask/dataframe/tests/test_dataframe.py::test_empty_quantile[dask] dask/dataframe/tests/test_dataframe.py::test_dataframe_quantile[dask-expected1] dask/dataframe/tests/test_dataframe.py::test_quantile_for_possibly_unsorted_q dask/dataframe/tests/test_dataframe.py::test_index dask/dataframe/tests/test_dataframe.py::test_assign dask/dataframe/tests/test_dataframe.py::test_assign_callable dask/dataframe/tests/test_dataframe.py::test_assign_dtypes dask/dataframe/tests/test_dataframe.py::test_map dask/dataframe/tests/test_dataframe.py::test_concat dask/dataframe/tests/test_dataframe.py::test_args dask/dataframe/tests/test_dataframe.py::test_known_divisions dask/dataframe/tests/test_dataframe.py::test_unknown_divisions dask/dataframe/tests/test_dataframe.py::test_with_min_count dask/dataframe/tests/test_dataframe.py::test_align[inner] dask/dataframe/tests/test_dataframe.py::test_align[outer] dask/dataframe/tests/test_dataframe.py::test_align[left] dask/dataframe/tests/test_dataframe.py::test_align[right] dask/dataframe/tests/test_dataframe.py::test_align_axis[inner] dask/dataframe/tests/test_dataframe.py::test_align_axis[outer] dask/dataframe/tests/test_dataframe.py::test_align_axis[left] dask/dataframe/tests/test_dataframe.py::test_align_axis[right] dask/dataframe/tests/test_dataframe.py::test_combine dask/dataframe/tests/test_dataframe.py::test_combine_first dask/dataframe/tests/test_dataframe.py::test_dataframe_picklable dask/dataframe/tests/test_dataframe.py::test_random_partitions dask/dataframe/tests/test_dataframe.py::test_series_round dask/dataframe/tests/test_dataframe.py::test_repartition_divisions dask/dataframe/tests/test_dataframe.py::test_repartition_on_pandas_dataframe dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-1-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-2-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-4-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-float-5-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-1-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-2-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-4-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>0-M8[ns]-5-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-1-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-2-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-4-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-float-5-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-1-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-2-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-4-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-1-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-1-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-4-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-4-False] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions[<lambda>1-M8[ns]-5-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-1kiB-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-1kiB-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-1kiB-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-1kiB-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-379-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-379-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-379-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>0-379-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-1kiB-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-1kiB-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-1kiB-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-1kiB-5-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-379-2-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-379-2-False] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-379-5-True] dask/dataframe/tests/test_dataframe.py::test_repartition_partition_size[<lambda>1-379-5-False] dask/dataframe/tests/test_dataframe.py::test_iter_chunks dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions_same_limits dask/dataframe/tests/test_dataframe.py::test_repartition_npartitions_numeric_edge_case dask/dataframe/tests/test_dataframe.py::test_repartition_object_index dask/dataframe/tests/test_dataframe.py::test_repartition_freq_divisions dask/dataframe/tests/test_dataframe.py::test_repartition_freq_errors dask/dataframe/tests/test_dataframe.py::test_repartition_freq_month dask/dataframe/tests/test_dataframe.py::test_repartition_input_errors dask/dataframe/tests/test_dataframe.py::test_fillna dask/dataframe/tests/test_dataframe.py::test_fillna_duplicate_index dask/dataframe/tests/test_dataframe.py::test_fillna_multi_dataframe dask/dataframe/tests/test_dataframe.py::test_ffill_bfill dask/dataframe/tests/test_dataframe.py::test_fillna_series_types dask/dataframe/tests/test_dataframe.py::test_sample dask/dataframe/tests/test_dataframe.py::test_sample_without_replacement dask/dataframe/tests/test_dataframe.py::test_sample_raises dask/dataframe/tests/test_dataframe.py::test_empty_max dask/dataframe/tests/test_dataframe.py::test_select_dtypes[include0-None] dask/dataframe/tests/test_dataframe.py::test_select_dtypes[None-exclude1] dask/dataframe/tests/test_dataframe.py::test_select_dtypes[include2-exclude2] dask/dataframe/tests/test_dataframe.py::test_select_dtypes[include3-None] dask/dataframe/tests/test_dataframe.py::test_deterministic_apply_concat_apply_names dask/dataframe/tests/test_dataframe.py::test_aca_meta_infer dask/dataframe/tests/test_dataframe.py::test_aca_split_every dask/dataframe/tests/test_dataframe.py::test_reduction_method dask/dataframe/tests/test_dataframe.py::test_reduction_method_split_every dask/dataframe/tests/test_dataframe.py::test_pipe dask/dataframe/tests/test_dataframe.py::test_gh_517 dask/dataframe/tests/test_dataframe.py::test_drop_axis_1 dask/dataframe/tests/test_dataframe.py::test_gh580 dask/dataframe/tests/test_dataframe.py::test_rename_dict dask/dataframe/tests/test_dataframe.py::test_rename_function dask/dataframe/tests/test_dataframe.py::test_rename_index dask/dataframe/tests/test_dataframe.py::test_to_frame dask/dataframe/tests/test_dataframe.py::test_to_dask_array_raises[False0] dask/dataframe/tests/test_dataframe.py::test_to_dask_array_raises[False1] dask/dataframe/tests/test_dataframe.py::test_to_dask_array_unknown[False0] dask/dataframe/tests/test_dataframe.py::test_to_dask_array_unknown[False1] dask/dataframe/tests/test_dataframe.py::test_to_dask_array[False0-lengths0] dask/dataframe/tests/test_dataframe.py::test_to_dask_array[False0-True] dask/dataframe/tests/test_dataframe.py::test_to_dask_array[False1-lengths0] dask/dataframe/tests/test_dataframe.py::test_to_dask_array[False1-True] dask/dataframe/tests/test_dataframe.py::test_apply dask/dataframe/tests/test_dataframe.py::test_applymap dask/dataframe/tests/test_dataframe.py::test_abs dask/dataframe/tests/test_dataframe.py::test_round dask/dataframe/tests/test_dataframe.py::test_cov dask/dataframe/tests/test_dataframe.py::test_corr dask/dataframe/tests/test_dataframe.py::test_corr_same_name dask/dataframe/tests/test_dataframe.py::test_cov_corr_meta dask/dataframe/tests/test_dataframe.py::test_cov_corr_mixed dask/dataframe/tests/test_dataframe.py::test_autocorr dask/dataframe/tests/test_dataframe.py::test_apply_infer_columns dask/dataframe/tests/test_dataframe.py::test_index_time_properties dask/dataframe/tests/test_dataframe.py::test_nlargest_nsmallest dask/dataframe/tests/test_dataframe.py::test_reset_index dask/dataframe/tests/test_dataframe.py::test_dataframe_compute_forward_kwargs dask/dataframe/tests/test_dataframe.py::test_series_iteritems dask/dataframe/tests/test_dataframe.py::test_series_iter dask/dataframe/tests/test_dataframe.py::test_dataframe_iterrows dask/dataframe/tests/test_dataframe.py::test_dataframe_itertuples dask/dataframe/tests/test_dataframe.py::test_dataframe_itertuples_with_index_false dask/dataframe/tests/test_dataframe.py::test_dataframe_itertuples_with_name_none dask/dataframe/tests/test_dataframe.py::test_astype dask/dataframe/tests/test_dataframe.py::test_groupby_callable dask/dataframe/tests/test_dataframe.py::test_methods_tokenize_differently dask/dataframe/tests/test_dataframe.py::test_categorize_info dask/dataframe/tests/test_dataframe.py::test_gh_1301 dask/dataframe/tests/test_dataframe.py::test_timeseries_sorted dask/dataframe/tests/test_dataframe.py::test_column_assignment dask/dataframe/tests/test_dataframe.py::test_array_assignment dask/dataframe/tests/test_dataframe.py::test_columns_assignment dask/dataframe/tests/test_dataframe.py::test_attribute_assignment dask/dataframe/tests/test_dataframe.py::test_setitem_triggering_realign dask/dataframe/tests/test_dataframe.py::test_inplace_operators dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx0-True] dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx0-False] dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx1-True] dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx1-False] dask/dataframe/tests/test_dataframe.py::test_idxmaxmin_empty_partitions dask/dataframe/tests/test_dataframe.py::test_getitem_meta dask/dataframe/tests/test_dataframe.py::test_getitem_multilevel dask/dataframe/tests/test_dataframe.py::test_getitem_string_subclass dask/dataframe/tests/test_dataframe.py::test_getitem_column_types[list] dask/dataframe/tests/test_dataframe.py::test_getitem_column_types[array] dask/dataframe/tests/test_dataframe.py::test_getitem_column_types[Series] dask/dataframe/tests/test_dataframe.py::test_getitem_column_types[Index] dask/dataframe/tests/test_dataframe.py::test_ipython_completion dask/dataframe/tests/test_dataframe.py::test_diff dask/dataframe/tests/test_dataframe.py::test_shift dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_DatetimeIndex[B-False] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_DatetimeIndex[D-True] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_DatetimeIndex[H-True] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_PeriodIndex[B-False] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_PeriodIndex[D-True] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_PeriodIndex[H-True] dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_TimedeltaIndex dask/dataframe/tests/test_dataframe.py::test_shift_with_freq_errors dask/dataframe/tests/test_dataframe.py::test_first_and_last[last] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-2-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-2-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-2-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-5-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-5-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[None-5-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-2-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-2-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-2-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-5-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-5-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[1-5-20] dask/dataframe/tests/test_dataframe.py::test_split_out_drop_duplicates[None] dask/dataframe/tests/test_dataframe.py::test_split_out_drop_duplicates[2] dask/dataframe/tests/test_dataframe.py::test_split_out_value_counts[None] dask/dataframe/tests/test_dataframe.py::test_split_out_value_counts[2] dask/dataframe/tests/test_dataframe.py::test_values dask/dataframe/tests/test_dataframe.py::test_copy dask/dataframe/tests/test_dataframe.py::test_del dask/dataframe/tests/test_dataframe.py::test_memory_usage[True-True] dask/dataframe/tests/test_dataframe.py::test_memory_usage[True-False] dask/dataframe/tests/test_dataframe.py::test_memory_usage[False-True] dask/dataframe/tests/test_dataframe.py::test_memory_usage[False-False] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[sum] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[mean] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[std] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[var] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[count] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[min] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[max] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[idxmin] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[idxmax] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[prod] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[all] dask/dataframe/tests/test_dataframe.py::test_dataframe_reductions_arithmetic[sem] dask/dataframe/tests/test_dataframe.py::test_to_datetime dask/dataframe/tests/test_dataframe.py::test_to_timedelta dask/dataframe/tests/test_dataframe.py::test_isna[values0] dask/dataframe/tests/test_dataframe.py::test_isna[values1] dask/dataframe/tests/test_dataframe.py::test_slice_on_filtered_boundary[0] dask/dataframe/tests/test_dataframe.py::test_slice_on_filtered_boundary[9] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_nonmonotonic dask/dataframe/tests/test_dataframe.py::test_boundary_slice_empty dask/dataframe/tests/test_dataframe.py::test_with_boundary[-1-None-False-False-drop0] dask/dataframe/tests/test_dataframe.py::test_with_boundary[-1-None-False-True-drop1] dask/dataframe/tests/test_dataframe.py::test_with_boundary[None-3-False-False-drop2] dask/dataframe/tests/test_dataframe.py::test_with_boundary[None-3-True-False-drop3] dask/dataframe/tests/test_dataframe.py::test_with_boundary[-0.5-None-False-False-drop4] dask/dataframe/tests/test_dataframe.py::test_with_boundary[-0.5-None-False-True-drop5] dask/dataframe/tests/test_dataframe.py::test_with_boundary[-1.5-None-False-True-drop6] dask/dataframe/tests/test_dataframe.py::test_with_boundary[None-3.5-False-False-drop7] dask/dataframe/tests/test_dataframe.py::test_with_boundary[None-3.5-True-False-drop8] dask/dataframe/tests/test_dataframe.py::test_with_boundary[None-2.5-False-False-drop9] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index0-0-9] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index1--1-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index2-None-10] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index3-None-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index4--1-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index5-None-2] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index6--2-3] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index7-None-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index8-left8-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index9-None-right9] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index10-left10-None] dask/dataframe/tests/test_dataframe.py::test_boundary_slice_same[index11-None-right11] dask/dataframe/tests/test_dataframe.py::test_better_errors_object_reductions dask/dataframe/tests/test_dataframe.py::test_sample_empty_partitions dask/dataframe/tests/test_dataframe.py::test_coerce dask/dataframe/tests/test_dataframe.py::test_bool dask/dataframe/tests/test_dataframe.py::test_cumulative_multiple_columns dask/dataframe/tests/test_dataframe.py::test_map_partition_array[asarray] dask/dataframe/tests/test_dataframe.py::test_map_partition_array[func1] dask/dataframe/tests/test_dataframe.py::test_mixed_dask_array_operations dask/dataframe/tests/test_dataframe.py::test_mixed_dask_array_operations_errors dask/dataframe/tests/test_dataframe.py::test_mixed_dask_array_multi_dimensional dask/dataframe/tests/test_dataframe.py::test_meta_raises dask/dataframe/tests/test_dataframe.py::test_map_partitions_delays_large_inputs dask/dataframe/tests/test_dataframe.py::test_partitions_indexer dask/dataframe/tests/test_dataframe.py::test_mod_eq dask/dataframe/tests/test_dataframe.py::test_setitem dask/dataframe/tests/test_dataframe.py::test_broadcast dask/dataframe/tests/test_dataframe.py::test_scalar_with_array dask/dataframe/tests/test_dataframe.py::test_has_parallel_type dask/dataframe/tests/test_dataframe.py::test_meta_error_message dask/dataframe/tests/test_dataframe.py::test_assign_index dask/dataframe/tests/test_dataframe.py::test_index_divisions dask/dataframe/tests/test_dataframe.py::test_replace dask/dataframe/tests/test_dataframe.py::test_map_partitions_delays_lists dask/dataframe/tests/test_dataframe.py::test_dtype_cast dask/dataframe/tests/test_dataframe.py::test_dataframe_explode dask/dataframe/tests/test_dataframe.py::test_series_explode dask/dataframe/tests/test_dataframe.py::test_pop dask/dataframe/tests/test_dataframe.py::test_simple_map_partitions dask/dataframe/tests/test_dataframe.py::test_iter dask/dataframe/tests/test_dataframe.py::test_dataframe_groupby_agg_empty_partitions dask/dataframe/tests/test_format.py::test_repr dask/dataframe/tests/test_format.py::test_dataframe_format dask/dataframe/tests/test_format.py::test_dataframe_format_with_index dask/dataframe/tests/test_format.py::test_dataframe_format_unknown_divisions dask/dataframe/tests/test_format.py::test_dataframe_format_long dask/dataframe/tests/test_format.py::test_series_format dask/dataframe/tests/test_format.py::test_series_format_long dask/dataframe/tests/test_format.py::test_index_format dask/dataframe/tests/test_format.py::test_duplicate_columns_repr dask/dataframe/tests/test_format.py::test_empty_repr dask/dataframe/tests/test_groupby.py::test_groupby_internal_repr dask/dataframe/tests/test_groupby.py::test_groupby_error dask/dataframe/tests/test_groupby.py::test_full_groupby dask/dataframe/tests/test_groupby.py::test_full_groupby_apply_multiarg dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[True-<lambda>0] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[True-<lambda>1] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[True-<lambda>2] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[True-<lambda>3] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[False-<lambda>0] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[False-<lambda>1] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[False-<lambda>2] dask/dataframe/tests/test_groupby.py::test_full_groupby_multilevel[False-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_dir dask/dataframe/tests/test_groupby.py::test_groupby_on_index[sync] dask/dataframe/tests/test_groupby.py::test_groupby_on_index[threads] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[sum-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[mean-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[min-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[max-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[count-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[size-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[std-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[var-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[nunique-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[first-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[last-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[prod-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_agg dask/dataframe/tests/test_groupby.py::test_groupby_get_group dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_nunique dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_nunique_across_group_same_value dask/dataframe/tests/test_groupby.py::test_series_groupby_propagates_names dask/dataframe/tests/test_groupby.py::test_series_groupby dask/dataframe/tests/test_groupby.py::test_series_groupby_errors dask/dataframe/tests/test_groupby.py::test_groupby_set_index dask/dataframe/tests/test_groupby.py::test_groupby_reduction_split[split_every] dask/dataframe/tests/test_groupby.py::test_groupby_reduction_split[split_out] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>0] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>1] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>2] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>3] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>4] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>5] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>6] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>7] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>8] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>9] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>10] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>0-<lambda>11] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>0] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>1] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>2] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>3] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>4] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>5] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>6] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>7] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>8] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>9] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>10] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle[<lambda>1-<lambda>11] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>0-<lambda>0] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>0-<lambda>1] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>0-<lambda>2] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>0-<lambda>3] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>0-<lambda>4] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>1-<lambda>0] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>1-<lambda>1] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>1-<lambda>2] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>1-<lambda>3] dask/dataframe/tests/test_groupby.py::test_apply_or_transform_shuffle_multilevel[<lambda>1-<lambda>4] dask/dataframe/tests/test_groupby.py::test_numeric_column_names dask/dataframe/tests/test_groupby.py::test_groupby_apply_tasks dask/dataframe/tests/test_groupby.py::test_groupby_multiprocessing dask/dataframe/tests/test_groupby.py::test_groupby_normalize_index dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-False-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>0-None-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-False-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>1-None-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-False-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>2-None-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-False-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>3-None-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-False-spec6] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec0] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec1] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec2] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec3] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-var] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec5] dask/dataframe/tests/test_groupby.py::test_aggregate__examples[<lambda>4-None-spec6] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-False-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-False-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-False-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-False-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-False-size] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-None-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-None-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-None-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-None-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>0-None-size] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-False-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-False-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-False-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-False-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-False-size] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-None-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-None-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-None-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-None-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>1-None-size] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-False-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-False-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-False-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-False-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-False-size] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-None-spec0] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-None-spec1] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-None-spec2] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-None-sum] dask/dataframe/tests/test_groupby.py::test_series_aggregate__examples[<lambda>2-None-size] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[sum] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[mean] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[min] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[max] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[count] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[size] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[std] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[var] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[cov] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[corr] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[nunique] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[first] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[last] dask/dataframe/tests/test_groupby.py::test_aggregate__single_element_groups[prod] dask/dataframe/tests/test_groupby.py::test_aggregate_build_agg_args__reuse_of_intermediates dask/dataframe/tests/test_groupby.py::test_aggregate__dask dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[sum-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[sum-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[sum-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[sum-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[sum-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[mean-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[mean-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[mean-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[mean-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[mean-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[min-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[min-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[min-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[min-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[min-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[max-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[max-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[max-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[max-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[max-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[count-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[count-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[count-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[count-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[count-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[size-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[size-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[size-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[size-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[size-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[std-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[std-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[std-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[std-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[std-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[var-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[var-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[var-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[var-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[var-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[nunique-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[nunique-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[nunique-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[nunique-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[nunique-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[first-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[first-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[first-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[first-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[first-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[last-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[last-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[last-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[last-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[last-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[prod-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[prod-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[prod-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[prod-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[prod-<lambda>4] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[sum-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[sum-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[sum-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[mean-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[mean-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[mean-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[min-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[min-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[min-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[max-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[max-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[max-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[count-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[count-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[count-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[size-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[size-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[size-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[std-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[std-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[std-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[var-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[var-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[var-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[cov-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[cov-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[cov-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[corr-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[corr-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[corr-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[nunique-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[nunique-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[nunique-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[first-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[first-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[first-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[last-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[last-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[last-<lambda>2] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[prod-<lambda>0] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[prod-<lambda>1] dask/dataframe/tests/test_groupby.py::test_series_aggregations_multilevel[prod-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>0-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>0-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>0-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>0-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>1-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>1-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>1-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>1-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>2-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>2-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>2-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_meta_content[<lambda>2-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupy_non_aligned_index dask/dataframe/tests/test_groupby.py::test_groupy_series_wrong_grouper dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-2-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-2-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-2-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-5-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-5-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[None-5-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-2-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-2-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-2-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-5-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-5-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[1-5-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-2-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-2-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-2-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-5-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-5-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[5-5-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-2-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-2-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-2-20] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-5-1] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-5-4] dask/dataframe/tests/test_groupby.py::test_hash_groupby_aggregate[20-5-20] dask/dataframe/tests/test_groupby.py::test_split_out_multi_column_groupby dask/dataframe/tests/test_groupby.py::test_groupby_split_out_num dask/dataframe/tests/test_groupby.py::test_groupby_not_supported dask/dataframe/tests/test_groupby.py::test_groupby_numeric_column dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-a-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-a-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-a-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-key1-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-key1-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumsum-key1-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-a-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-a-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-a-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-key1-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-key1-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumprod-key1-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-a-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-a-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-a-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-key1-c] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-key1-d] dask/dataframe/tests/test_groupby.py::test_cumulative[cumcount-key1-sel2] dask/dataframe/tests/test_groupby.py::test_cumulative_axis1[cumsum] dask/dataframe/tests/test_groupby.py::test_cumulative_axis1[cumprod] dask/dataframe/tests/test_groupby.py::test_groupby_unaligned_index dask/dataframe/tests/test_groupby.py::test_groupby_string_label dask/dataframe/tests/test_groupby.py::test_groupby_dataframe_cum_caching dask/dataframe/tests/test_groupby.py::test_groupby_series_cum_caching dask/dataframe/tests/test_groupby.py::test_groupby_slice_agg_reduces dask/dataframe/tests/test_groupby.py::test_groupby_agg_grouper_single dask/dataframe/tests/test_groupby.py::test_groupby_agg_grouper_multiple[a] dask/dataframe/tests/test_groupby.py::test_groupby_agg_grouper_multiple[slice_1] dask/dataframe/tests/test_groupby.py::test_groupby_agg_grouper_multiple[slice_2] dask/dataframe/tests/test_groupby.py::test_groupby_agg_grouper_multiple[slice_3] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[cumprod] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[cumcount] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[cumsum] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[var] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[sum] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[mean] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[count] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[size] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[std] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[min] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[max] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[first] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[last] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_agg_funcs[prod] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[amin-group_args0] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[amin-group_args1] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[amin-group_args2] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[amin-idx] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[mean-group_args0] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[mean-group_args1] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[mean-group_args2] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[mean-idx] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[<lambda>-group_args0] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[<lambda>-group_args1] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[<lambda>-group_args2] dask/dataframe/tests/test_groupby.py::test_groupby_column_and_index_apply[<lambda>-idx] dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_agg_custom_sum[pandas_spec0-dask_spec0-False] dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_agg_custom_sum[pandas_spec1-dask_spec1-True] dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_agg_custom_sum[pandas_spec2-dask_spec2-False] dask/dataframe/tests/test_groupby.py::test_dataframe_groupby_agg_custom_sum[pandas_spec3-dask_spec3-False] dask/dataframe/tests/test_groupby.py::test_series_groupby_agg_custom_mean[mean-mean] dask/dataframe/tests/test_groupby.py::test_series_groupby_agg_custom_mean[pandas_spec1-dask_spec1] dask/dataframe/tests/test_groupby.py::test_series_groupby_agg_custom_mean[pandas_spec2-dask_spec2] dask/dataframe/tests/test_groupby.py::test_groupby_agg_custom__name_clash_with_internal_same_column dask/dataframe/tests/test_groupby.py::test_groupby_agg_custom__name_clash_with_internal_different_column dask/dataframe/tests/test_groupby.py::test_groupby_agg_custom__mode dask/dataframe/tests/test_groupby.py::test_groupby_select_column_agg dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>1] dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>2] dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>3] dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>4] dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>5] dask/dataframe/tests/test_groupby.py::test_std_columns_int dask/dataframe/tests/test_groupby.py::test_timeseries dask/dataframe/tests/test_groupby.py::test_with_min_count[0] dask/dataframe/tests/test_groupby.py::test_with_min_count[1] dask/dataframe/tests/test_groupby.py::test_with_min_count[2] dask/dataframe/tests/test_groupby.py::test_with_min_count[3] dask/dataframe/tests/test_groupby.py::test_groupby_group_keys dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmin dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmin_skipna[True] dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmin_skipna[False] dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmax dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmax_skipna[True] dask/dataframe/tests/test_groupby.py::test_df_groupby_idxmax_skipna[False] dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmin dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmin_skipna[True] dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmin_skipna[False] dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmax dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmax_skipna[True] dask/dataframe/tests/test_groupby.py::test_series_groupby_idxmax_skipna[False] dask/dataframe/tests/test_groupby.py::test_groupby_unique dask/dataframe/tests/test_groupby.py::test_groupby_transform_funcs[<lambda>] dask/dataframe/tests/test_groupby.py::test_groupby_transform_funcs[sum0] dask/dataframe/tests/test_groupby.py::test_groupby_transform_funcs[sum1] dask/dataframe/tests/test_groupby.py::test_groupby_transform_funcs[rank] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-1] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-2] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-3] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-4] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-5] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-6] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-7] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-8] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[True-9] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-1] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-2] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-3] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-4] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-5] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-6] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-7] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-8] dask/dataframe/tests/test_groupby.py::test_groupby_transform_ufunc_partitioning[False-9] dask/dataframe/tests/test_groupby.py::test_groupby_aggregate_categoricals[<lambda>-<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_aggregate_categoricals[<lambda>-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_aggregate_categoricals[<lambda>-<lambda>2] dask/dataframe/tests/test_groupby.py::test_groupby_aggregate_categoricals[<lambda>-<lambda>3] dask/dataframe/tests/test_groupby.py::test_rounding_negative_var dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column0-2] dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column0-3] dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column1-2] dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column1-3] dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column2-2] dask/dataframe/tests/test_groupby.py::test_groupby_split_out_multiindex[column2-3] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj0] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj1] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj2] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj3] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj4] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj5] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj6] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj7] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj8] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj9] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj10] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj11] dask/dataframe/tests/test_hashing.py::test_hash_pandas_object[obj12] dask/dataframe/tests/test_hashing.py::test_categorical_consistency dask/dataframe/tests/test_hashing.py::test_object_missing_values dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj0] dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj2] dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj3] dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj4] dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj5] dask/dataframe/tests/test_indexing.py::test_loc dask/dataframe/tests/test_indexing.py::test_loc_non_informative_index dask/dataframe/tests/test_indexing.py::test_loc_with_series dask/dataframe/tests/test_indexing.py::test_loc_with_array dask/dataframe/tests/test_indexing.py::test_loc_with_array_different_partition dask/dataframe/tests/test_indexing.py::test_loc_with_series_different_partition dask/dataframe/tests/test_indexing.py::test_loc2d dask/dataframe/tests/test_indexing.py::test_loc2d_with_known_divisions dask/dataframe/tests/test_indexing.py::test_loc2d_with_unknown_divisions dask/dataframe/tests/test_indexing.py::test_loc2d_duplicated_columns dask/dataframe/tests/test_indexing.py::test_getitem dask/dataframe/tests/test_indexing.py::test_getitem_slice dask/dataframe/tests/test_indexing.py::test_getitem_integer_slice dask/dataframe/tests/test_indexing.py::test_coerce_loc_index dask/dataframe/tests/test_indexing.py::test_loc_period_str dask/dataframe/tests/test_indexing.py::test_to_series dask/dataframe/tests/test_indexing.py::test_to_frame dask/dataframe/tests/test_indexing.py::test_to_frame_name dask/dataframe/tests/test_indexing.py::test_iloc[0] dask/dataframe/tests/test_indexing.py::test_iloc[indexer1] dask/dataframe/tests/test_indexing.py::test_iloc[indexer2] dask/dataframe/tests/test_indexing.py::test_iloc[indexer3] dask/dataframe/tests/test_indexing.py::test_iloc[indexer4] dask/dataframe/tests/test_indexing.py::test_iloc_series dask/dataframe/tests/test_indexing.py::test_iloc_raises dask/dataframe/tests/test_multi.py::test_align_partitions dask/dataframe/tests/test_multi.py::test_align_partitions_unknown_divisions dask/dataframe/tests/test_multi.py::test__maybe_align_partitions dask/dataframe/tests/test_multi.py::test_merge_indexed_dataframe_to_indexed_dataframe dask/dataframe/tests/test_multi.py::test_hash_join[disk-inner] dask/dataframe/tests/test_multi.py::test_hash_join[disk-left] dask/dataframe/tests/test_multi.py::test_hash_join[disk-right] dask/dataframe/tests/test_multi.py::test_hash_join[disk-outer] dask/dataframe/tests/test_multi.py::test_hash_join[tasks-inner] dask/dataframe/tests/test_multi.py::test_hash_join[tasks-left] dask/dataframe/tests/test_multi.py::test_hash_join[tasks-right] dask/dataframe/tests/test_multi.py::test_hash_join[tasks-outer] dask/dataframe/tests/test_multi.py::test_sequential_joins dask/dataframe/tests/test_multi.py::test_merge_asof_on_by dask/dataframe/tests/test_multi.py::test_merge_asof_on_by_tolerance dask/dataframe/tests/test_multi.py::test_merge_asof_on_by_tolerance_no_exact_matches dask/dataframe/tests/test_multi.py::test_merge_asof_unsorted_raises dask/dataframe/tests/test_multi.py::test_indexed_concat[inner] dask/dataframe/tests/test_multi.py::test_indexed_concat[outer] dask/dataframe/tests/test_multi.py::test_concat[inner] dask/dataframe/tests/test_multi.py::test_concat[outer] dask/dataframe/tests/test_multi.py::test_concat_different_dtypes[inner] dask/dataframe/tests/test_multi.py::test_concat_different_dtypes[outer] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[True-inner] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[True-outer] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[True-left] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[True-right] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[False-inner] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[False-outer] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[False-left] dask/dataframe/tests/test_multi.py::test_merge_columns_dtypes[False-right] dask/dataframe/tests/test_multi.py::test_merge[disk-inner] dask/dataframe/tests/test_multi.py::test_merge[disk-outer] dask/dataframe/tests/test_multi.py::test_merge[disk-left] dask/dataframe/tests/test_multi.py::test_merge[disk-right] dask/dataframe/tests/test_multi.py::test_merge[tasks-inner] dask/dataframe/tests/test_multi.py::test_merge[tasks-outer] dask/dataframe/tests/test_multi.py::test_merge[tasks-left] dask/dataframe/tests/test_multi.py::test_merge[tasks-right] dask/dataframe/tests/test_multi.py::test_merge_tasks_passes_through dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[disk-inner] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[disk-outer] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[disk-left] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[disk-right] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[tasks-inner] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[tasks-outer] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[tasks-left] dask/dataframe/tests/test_multi.py::test_join_by_index_patterns[tasks-right] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[disk-inner] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[disk-outer] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[disk-left] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[disk-right] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[tasks-inner] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[tasks-outer] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[tasks-left] dask/dataframe/tests/test_multi.py::test_merge_by_multiple_columns[tasks-right] dask/dataframe/tests/test_multi.py::test_melt dask/dataframe/tests/test_multi.py::test_cheap_inner_merge_with_pandas_object dask/dataframe/tests/test_multi.py::test_cheap_single_partition_merge dask/dataframe/tests/test_multi.py::test_cheap_single_partition_merge_divisions dask/dataframe/tests/test_multi.py::test_cheap_single_parition_merge_left_right[left] dask/dataframe/tests/test_multi.py::test_cheap_single_parition_merge_left_right[right] dask/dataframe/tests/test_multi.py::test_cheap_single_partition_merge_on_index dask/dataframe/tests/test_multi.py::test_merge_maintains_columns dask/dataframe/tests/test_multi.py::test_merge_index_without_divisions[disk] dask/dataframe/tests/test_multi.py::test_merge_index_without_divisions[tasks] dask/dataframe/tests/test_multi.py::test_half_indexed_dataframe_avoids_shuffle dask/dataframe/tests/test_multi.py::test_errors_for_merge_on_frame_columns dask/dataframe/tests/test_multi.py::test_concat_one_series dask/dataframe/tests/test_multi.py::test_concat_unknown_divisions dask/dataframe/tests/test_multi.py::test_concat_unknown_divisions_errors dask/dataframe/tests/test_multi.py::test_concat2 dask/dataframe/tests/test_multi.py::test_concat3 dask/dataframe/tests/test_multi.py::test_concat4_interleave_partitions dask/dataframe/tests/test_multi.py::test_concat5 dask/dataframe/tests/test_multi.py::test_concat_categorical[True-True-False] dask/dataframe/tests/test_multi.py::test_concat_categorical[True-False-True] dask/dataframe/tests/test_multi.py::test_concat_categorical[True-False-False] dask/dataframe/tests/test_multi.py::test_concat_categorical[False-True-False] dask/dataframe/tests/test_multi.py::test_concat_categorical[False-False-True] dask/dataframe/tests/test_multi.py::test_concat_categorical[False-False-False] dask/dataframe/tests/test_multi.py::test_concat_datetimeindex dask/dataframe/tests/test_multi.py::test_append dask/dataframe/tests/test_multi.py::test_append2 dask/dataframe/tests/test_multi.py::test_append_lose_divisions dask/dataframe/tests/test_multi.py::test_singleton_divisions dask/dataframe/tests/test_multi.py::test_repartition_repeated_divisions dask/dataframe/tests/test_multi.py::test_multi_duplicate_divisions dask/dataframe/tests/test_multi.py::test_dtype_equality_warning dask/dataframe/tests/test_multi.py::test_groupby_concat_cudf[pandas] dask/dataframe/tests/test_reshape.py::test_get_dummies[data0] dask/dataframe/tests/test_reshape.py::test_get_dummies[data1] dask/dataframe/tests/test_reshape.py::test_get_dummies[data2] dask/dataframe/tests/test_reshape.py::test_get_dummies_object dask/dataframe/tests/test_reshape.py::test_get_dummies_kwargs dask/dataframe/tests/test_reshape.py::test_get_dummies_sparse dask/dataframe/tests/test_reshape.py::test_get_dummies_sparse_mix dask/dataframe/tests/test_reshape.py::test_get_dummies_dtype dask/dataframe/tests/test_reshape.py::test_get_dummies_errors dask/dataframe/tests/test_reshape.py::test_pivot_table[mean] dask/dataframe/tests/test_reshape.py::test_pivot_table[sum] dask/dataframe/tests/test_reshape.py::test_pivot_table[count] dask/dataframe/tests/test_reshape.py::test_pivot_table_dtype dask/dataframe/tests/test_reshape.py::test_pivot_table_index_dtype dask/dataframe/tests/test_reshape.py::test_pivot_table_errors dask/dataframe/tests/test_shuffle.py::test_shuffle[disk] dask/dataframe/tests/test_shuffle.py::test_shuffle[tasks] dask/dataframe/tests/test_shuffle.py::test_default_partitions dask/dataframe/tests/test_shuffle.py::test_shuffle_npartitions_task dask/dataframe/tests/test_shuffle.py::test_index_with_non_series[disk] dask/dataframe/tests/test_shuffle.py::test_index_with_non_series[tasks] dask/dataframe/tests/test_shuffle.py::test_index_with_dataframe[disk] dask/dataframe/tests/test_shuffle.py::test_index_with_dataframe[tasks] dask/dataframe/tests/test_shuffle.py::test_shuffle_from_one_partition_to_one_other[disk] dask/dataframe/tests/test_shuffle.py::test_shuffle_from_one_partition_to_one_other[tasks] dask/dataframe/tests/test_shuffle.py::test_shuffle_empty_partitions[disk] dask/dataframe/tests/test_shuffle.py::test_shuffle_empty_partitions[tasks] dask/dataframe/tests/test_shuffle.py::test_partitioning_index dask/dataframe/tests/test_shuffle.py::test_set_index_tasks[1] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks[4] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks[7] dask/dataframe/tests/test_shuffle.py::test_set_index_self_index[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_self_index[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_names[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks_2[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks_2[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks_3[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_tasks_3[tasks] dask/dataframe/tests/test_shuffle.py::test_shuffle_sort[tasks] dask/dataframe/tests/test_shuffle.py::test_shuffle_sort[disk] dask/dataframe/tests/test_shuffle.py::test_rearrange[threads-tasks] dask/dataframe/tests/test_shuffle.py::test_rearrange[threads-disk] dask/dataframe/tests/test_shuffle.py::test_rearrange[processes-tasks] dask/dataframe/tests/test_shuffle.py::test_rearrange[processes-disk] dask/dataframe/tests/test_shuffle.py::test_rearrange_by_column_with_narrow_divisions dask/dataframe/tests/test_shuffle.py::test_maybe_buffered_partd dask/dataframe/tests/test_shuffle.py::test_set_index_with_explicit_divisions dask/dataframe/tests/test_shuffle.py::test_set_index_divisions_2 dask/dataframe/tests/test_shuffle.py::test_set_index_divisions_compute dask/dataframe/tests/test_shuffle.py::test_set_index_divisions_sorted dask/dataframe/tests/test_shuffle.py::test_set_index_reduces_partitions_small[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_reduces_partitions_small[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_reduces_partitions_large[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_reduces_partitions_large[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_doesnt_increase_partitions[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_doesnt_increase_partitions[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_detects_sorted_data[disk] dask/dataframe/tests/test_shuffle.py::test_set_index_detects_sorted_data[tasks] dask/dataframe/tests/test_shuffle.py::test_set_index_sorts dask/dataframe/tests/test_shuffle.py::test_set_index dask/dataframe/tests/test_shuffle.py::test_set_index_interpolate dask/dataframe/tests/test_shuffle.py::test_set_index_interpolate_int dask/dataframe/tests/test_shuffle.py::test_set_index_drop[True] dask/dataframe/tests/test_shuffle.py::test_set_index_drop[False] dask/dataframe/tests/test_shuffle.py::test_set_index_raises_error_on_bad_input dask/dataframe/tests/test_shuffle.py::test_set_index_sorted_true dask/dataframe/tests/test_shuffle.py::test_set_index_sorted_single_partition dask/dataframe/tests/test_shuffle.py::test_set_index_sorted_min_max_same dask/dataframe/tests/test_shuffle.py::test_set_index_empty_partition dask/dataframe/tests/test_shuffle.py::test_set_index_categorical dask/dataframe/tests/test_shuffle.py::test_compute_divisions dask/dataframe/tests/test_shuffle.py::test_temporary_directory dask/dataframe/tests/test_shuffle.py::test_empty_partitions dask/dataframe/tests/test_shuffle.py::test_remove_nans dask/dataframe/tests/test_shuffle.py::test_set_index_does_not_repeat_work_due_to_optimizations[None] dask/dataframe/tests/test_shuffle.py::test_set_index_does_not_repeat_work_due_to_optimizations[auto] dask/dataframe/tests/test_shuffle.py::test_set_index_errors_with_inplace_kwarg dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[conj-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[log-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[log2-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[log10-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[log1p-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[expm1-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[sqrt-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[square-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[sin-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[cos-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[tan-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsin-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccos-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctan-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[sinh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[cosh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[tanh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arcsinh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arccosh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[arctanh-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[deg2rad-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[rad2deg-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[isfinite-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[isinf-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[isnan-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[signbit-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[degrees-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[radians-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[rint-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[fabs-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[sign-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[absolute-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[floor-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[ceil-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[trunc-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[logical_not-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[cbrt-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[exp2-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[negative-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[reciprocal-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input0] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input1] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input2] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input3] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input4] dask/dataframe/tests/test_ufunc.py::test_ufunc[spacing-pandas_input5] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[isreal] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[iscomplex] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[real] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[imag] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[angle] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[i0] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[sinc] dask/dataframe/tests/test_ufunc.py::test_ufunc_array_wrap[nan_to_num] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logaddexp] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logaddexp2] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-arctan2] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-hypot] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-copysign] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-nextafter] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-ldexp] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-fmod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_and0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_or0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_xor0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-maximum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-minimum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-fmax] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-fmin] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-greater] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-greater_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-less] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-less_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-not_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_or1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_and1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>0-logical_xor1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logaddexp] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logaddexp2] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-arctan2] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-hypot] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-copysign] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-nextafter] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-ldexp] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-fmod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_and0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_or0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_xor0] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-maximum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-minimum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-fmax] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-fmin] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-greater] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-greater_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-less] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-less_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-not_equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-equal] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_or1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_and1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_2args[<lambda>1-logical_xor1] dask/dataframe/tests/test_ufunc.py::test_clip[pandas0-5-50] dask/dataframe/tests/test_ufunc.py::test_clip[pandas1-5.5-40.5] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[conj] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[exp] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[log] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[log2] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[log10] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[log1p] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[expm1] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[sqrt] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[square] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[sin] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[cos] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[tan] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arcsin] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arccos] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arctan] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[sinh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[cosh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[tanh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arcsinh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arccosh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[arctanh] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[deg2rad] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[rad2deg] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[isfinite] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[isinf] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[isnan] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[signbit] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[degrees] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[radians] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[rint] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[fabs] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[sign] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[absolute] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[floor] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[ceil] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[trunc] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[logical_not] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[cbrt] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[exp2] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[negative] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[reciprocal] dask/dataframe/tests/test_ufunc.py::test_frame_ufunc_out[spacing] dask/dataframe/tests/test_ufunc.py::test_frame_2ufunc_out dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp2-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp2-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp2-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logaddexp2-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[arctan2-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[arctan2-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[arctan2-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[arctan2-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[hypot-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[hypot-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[hypot-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[hypot-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[copysign-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[copysign-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[copysign-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[copysign-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[nextafter-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[nextafter-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[nextafter-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[nextafter-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[ldexp-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[ldexp-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[ldexp-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[ldexp-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmod-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmod-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmod-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmod-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and0-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and0-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and0-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and0-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or0-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or0-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or0-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or0-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor0-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor0-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor0-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor0-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[maximum-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[maximum-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[maximum-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[maximum-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[minimum-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[minimum-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[minimum-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[minimum-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmax-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmax-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmax-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmax-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmin-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmin-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmin-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[fmin-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater_equal-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater_equal-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater_equal-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[greater_equal-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less_equal-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less_equal-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less_equal-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[less_equal-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[not_equal-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[not_equal-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[not_equal-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[not_equal-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[equal-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[equal-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[equal-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[equal-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or1-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or1-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or1-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_or1-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and1-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and1-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and1-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_and1-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor1-2-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor1-2-arg11] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor1-arg21-arg10] dask/dataframe/tests/test_ufunc.py::test_mixed_types[logical_xor1-arg21-arg11] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logaddexp] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logaddexp2] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-arctan2] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-hypot] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-copysign] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-nextafter] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-ldexp] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-fmod] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_and0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_or0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_xor0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-maximum] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-minimum] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-fmax] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-fmin] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-greater] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-greater_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-less] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-less_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-not_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_or1] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_and1] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas0-darray0-logical_xor1] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logaddexp] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logaddexp2] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-arctan2] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-hypot] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-copysign] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-nextafter] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-fmod] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_and0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_or0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_xor0] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-maximum] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-minimum] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-fmax] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-fmin] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-greater] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-greater_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-less] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-less_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-not_equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-equal] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_or1] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_and1] dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-logical_xor1] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-conj-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-conj-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-conj-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-conj-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-conj-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log2-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log2-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log2-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log2-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log2-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log10-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log10-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log10-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log10-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log10-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log1p-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log1p-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log1p-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log1p-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-log1p-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-expm1-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-expm1-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-expm1-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-expm1-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-expm1-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sqrt-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sqrt-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sqrt-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sqrt-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sqrt-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-square-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-square-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-square-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-square-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-square-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sin-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sin-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sin-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sin-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sin-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cos-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cos-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cos-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cos-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cos-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsin-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsin-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsin-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsin-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsin-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccos-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccos-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccos-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccos-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccos-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sinh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sinh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sinh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sinh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sinh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cosh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cosh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cosh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cosh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cosh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tanh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tanh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tanh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tanh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-tanh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsinh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsinh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsinh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsinh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arcsinh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccosh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccosh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccosh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccosh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arccosh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctanh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctanh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctanh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctanh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-arctanh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-deg2rad-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-deg2rad-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-deg2rad-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-deg2rad-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-deg2rad-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rad2deg-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rad2deg-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rad2deg-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rad2deg-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rad2deg-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isfinite-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isfinite-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isfinite-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isfinite-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isfinite-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isinf-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isinf-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isinf-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isinf-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isinf-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isnan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isnan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isnan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isnan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-isnan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-signbit-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-signbit-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-signbit-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-signbit-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-signbit-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-degrees-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-degrees-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-degrees-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-degrees-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-degrees-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-radians-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-radians-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-radians-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-radians-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-radians-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rint-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rint-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rint-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rint-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-rint-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-fabs-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-fabs-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-fabs-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-fabs-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-fabs-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sign-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sign-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sign-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sign-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-sign-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-absolute-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-absolute-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-absolute-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-absolute-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-absolute-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-floor-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-floor-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-floor-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-floor-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-floor-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-ceil-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-ceil-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-ceil-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-ceil-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-ceil-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-trunc-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-trunc-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-trunc-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-trunc-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-trunc-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-logical_not-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-logical_not-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-logical_not-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-logical_not-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-logical_not-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cbrt-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cbrt-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cbrt-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cbrt-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-cbrt-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp2-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp2-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp2-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp2-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-exp2-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-negative-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-negative-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-negative-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-negative-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-negative-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-reciprocal-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-reciprocal-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-reciprocal-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-reciprocal-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-reciprocal-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-spacing-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-spacing-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-spacing-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-spacing-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas0-spacing-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-conj-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-conj-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-conj-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-conj-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log2-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log2-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log2-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log2-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log2-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log10-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log10-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log10-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log10-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log10-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log1p-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log1p-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log1p-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log1p-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-log1p-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-expm1-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-expm1-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-expm1-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-expm1-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-expm1-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sqrt-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sqrt-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sqrt-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sqrt-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sqrt-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-square-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-square-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-square-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-square-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sin-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sin-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sin-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sin-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sin-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cos-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cos-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cos-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cos-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cos-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsin-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsin-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsin-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsin-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsin-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccos-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccos-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccos-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccos-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccos-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sinh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sinh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sinh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sinh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sinh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cosh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cosh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cosh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cosh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cosh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tanh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tanh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tanh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tanh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-tanh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsinh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsinh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsinh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsinh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arcsinh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccosh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccosh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccosh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccosh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arccosh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctanh-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctanh-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctanh-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctanh-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-arctanh-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-deg2rad-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-deg2rad-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-deg2rad-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-deg2rad-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-deg2rad-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rad2deg-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rad2deg-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rad2deg-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rad2deg-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rad2deg-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isfinite-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isfinite-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isfinite-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isfinite-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isfinite-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isinf-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isinf-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isinf-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isinf-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isinf-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isnan-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isnan-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isnan-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isnan-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-isnan-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-signbit-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-signbit-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-signbit-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-signbit-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-signbit-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-degrees-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-degrees-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-degrees-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-degrees-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-degrees-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-radians-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-radians-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-radians-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-radians-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-radians-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rint-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rint-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rint-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rint-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-rint-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-fabs-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-fabs-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-fabs-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-fabs-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-fabs-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sign-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sign-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sign-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sign-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-sign-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-absolute-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-absolute-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-absolute-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-absolute-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-floor-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-floor-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-floor-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-floor-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-floor-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-ceil-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-ceil-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-ceil-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-ceil-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-ceil-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-trunc-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-trunc-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-trunc-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-trunc-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-trunc-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-logical_not-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-logical_not-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-logical_not-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-logical_not-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-logical_not-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cbrt-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cbrt-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cbrt-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cbrt-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-cbrt-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp2-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp2-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp2-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp2-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-exp2-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-negative-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-negative-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-negative-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-negative-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-reciprocal-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-reciprocal-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-reciprocal-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-reciprocal-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-reciprocal-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-spacing-sum] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-spacing-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-spacing-min] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-spacing-max] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-spacing-mean] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[15-pandas0] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[15-pandas1] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[16.40-pandas0] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[16.40-pandas1] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[scalar2-pandas0] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[scalar2-pandas1] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[16.41-pandas0] dask/dataframe/tests/test_ufunc.py::test_ufunc_numpy_scalar_comparison[16.41-pandas1] dask/dataframe/tests/test_utils_dataframe.py::test_shard_df_on_index dask/dataframe/tests/test_utils_dataframe.py::test_make_meta dask/dataframe/tests/test_utils_dataframe.py::test_meta_duplicated dask/dataframe/tests/test_utils_dataframe.py::test_meta_nonempty_empty_categories dask/dataframe/tests/test_utils_dataframe.py::test_meta_nonempty_index dask/dataframe/tests/test_utils_dataframe.py::test_meta_nonempty_uint64index dask/dataframe/tests/test_utils_dataframe.py::test_meta_nonempty_scalar dask/dataframe/tests/test_utils_dataframe.py::test_raise_on_meta_error dask/dataframe/tests/test_utils_dataframe.py::test_check_meta dask/dataframe/tests/test_utils_dataframe.py::test_check_meta_typename dask/dataframe/tests/test_utils_dataframe.py::test_is_dataframe_like[True] dask/dataframe/tests/test_utils_dataframe.py::test_is_dataframe_like[False] dask/dataframe/tests/test_utils_dataframe.py::test_apply_and_enforce_message dask/tests/test_base.py::test_normalize_function dask/tests/test_base.py::test_tokenize dask/tests/test_base.py::test_tokenize_numpy_array_consistent_on_values dask/tests/test_base.py::test_tokenize_numpy_array_supports_uneven_sizes dask/tests/test_base.py::test_tokenize_discontiguous_numpy_array dask/tests/test_base.py::test_tokenize_numpy_datetime dask/tests/test_base.py::test_tokenize_numpy_scalar dask/tests/test_base.py::test_tokenize_numpy_scalar_string_rep dask/tests/test_base.py::test_tokenize_numpy_array_on_object_dtype dask/tests/test_base.py::test_tokenize_numpy_memmap_offset dask/tests/test_base.py::test_tokenize_numpy_memmap dask/tests/test_base.py::test_tokenize_numpy_memmap_no_filename dask/tests/test_base.py::test_tokenize_numpy_ufunc_consistent dask/tests/test_base.py::test_tokenize_partial_func_args_kwargs_consistent dask/tests/test_base.py::test_normalize_base dask/tests/test_base.py::test_tokenize_pandas dask/tests/test_base.py::test_tokenize_pandas_invalid_unicode dask/tests/test_base.py::test_tokenize_pandas_mixed_unicode_bytes dask/tests/test_base.py::test_tokenize_pandas_no_pickle dask/tests/test_base.py::test_tokenize_kwargs dask/tests/test_base.py::test_tokenize_same_repr dask/tests/test_base.py::test_tokenize_method dask/tests/test_base.py::test_tokenize_sequences dask/tests/test_base.py::test_tokenize_dict dask/tests/test_base.py::test_tokenize_set dask/tests/test_base.py::test_tokenize_ordered_dict dask/tests/test_base.py::test_tokenize_object_array_with_nans dask/tests/test_base.py::test_tokenize_base_types[1] dask/tests/test_base.py::test_tokenize_base_types[True] dask/tests/test_base.py::test_tokenize_base_types[a0] dask/tests/test_base.py::test_tokenize_base_types[a1] dask/tests/test_base.py::test_tokenize_base_types[1.0] dask/tests/test_base.py::test_tokenize_base_types[1j0] dask/tests/test_base.py::test_tokenize_base_types[1j1] dask/tests/test_base.py::test_tokenize_base_types[x7] dask/tests/test_base.py::test_tokenize_base_types[x8] dask/tests/test_base.py::test_tokenize_base_types[x9] dask/tests/test_base.py::test_tokenize_base_types[None] dask/tests/test_base.py::test_tokenize_base_types[str] dask/tests/test_base.py::test_tokenize_base_types[int] dask/tests/test_base.py::test_tokenize_numpy_matrix dask/tests/test_base.py::test_is_dask_collection dask/tests/test_base.py::test_unpack_collections dask/tests/test_base.py::test_custom_collection dask/tests/test_base.py::test_compute_no_opt dask/tests/test_base.py::test_compute_array dask/tests/test_base.py::test_persist_array dask/tests/test_base.py::test_compute_dataframe dask/tests/test_base.py::test_compute_array_dataframe dask/tests/test_base.py::test_compute_dataframe_valid_unicode_in_bytes dask/tests/test_base.py::test_compute_dataframe_invalid_unicode dask/tests/test_base.py::test_compute_array_bag dask/tests/test_base.py::test_compute_with_literal dask/tests/test_base.py::test_compute_nested dask/tests/test_base.py::test_use_cloudpickle_to_tokenize_functions_in__main__ dask/tests/test_base.py::test_optimizations_keyword dask/tests/test_base.py::test_optimize dask/tests/test_base.py::test_optimize_nested dask/tests/test_base.py::test_default_imports dask/tests/test_base.py::test_persist_literals dask/tests/test_base.py::test_persist_nested dask/tests/test_base.py::test_persist_delayed dask/tests/test_base.py::test_persist_array_bag dask/tests/test_base.py::test_normalize_function_limited_size dask/tests/test_base.py::test_optimize_globals dask/tests/test_base.py::test_optimize_None dask/tests/test_base.py::test_scheduler_keyword dask/tests/test_base.py::test_raise_get_keyword dask/tests/test_base.py::test_get_scheduler dask/tests/test_base.py::test_callable_scheduler dask/tests/test_base.py::test_num_workers_config[threads] dask/tests/test_base.py::test_num_workers_config[processes] dask/tests/test_distributed.py::test_can_import_client dask/tests/test_distributed.py::test_persist dask/tests/test_distributed.py::test_persist_nested dask/tests/test_distributed.py::test_futures_to_delayed_dataframe dask/tests/test_distributed.py::test_futures_to_delayed_bag dask/tests/test_distributed.py::test_futures_to_delayed_array dask/tests/test_distributed.py::test_local_get_with_distributed_active dask/tests/test_distributed.py::test_serializable_groupby_agg dask/tests/test_distributed.py::test_futures_in_graph dask/tests/test_distributed.py::test_scheduler_equals_client dask/tests/test_distributed.py::test_await dask/tests/test_distributed.py::test_local_scheduler dask/tests/test_order.py::test_ordering_keeps_groups_together[abcde] dask/tests/test_order.py::test_ordering_keeps_groups_together[edcba] dask/tests/test_order.py::test_avoid_broker_nodes[abcde] dask/tests/test_order.py::test_avoid_broker_nodes[edcba] dask/tests/test_order.py::test_base_of_reduce_preferred[abcde] dask/tests/test_order.py::test_base_of_reduce_preferred[edcba] dask/tests/test_order.py::test_avoid_upwards_branching_complex[abcde] dask/tests/test_order.py::test_avoid_upwards_branching_complex[edcba] dask/tests/test_order.py::test_deep_bases_win_over_dependents[abcde] dask/tests/test_order.py::test_deep_bases_win_over_dependents[edcba] dask/tests/test_order.py::test_prefer_deep[abcde] dask/tests/test_order.py::test_prefer_deep[edcba] dask/tests/test_order.py::test_stacklimit[abcde] dask/tests/test_order.py::test_stacklimit[edcba] dask/tests/test_order.py::test_break_ties_by_str[abcde] dask/tests/test_order.py::test_break_ties_by_str[edcba] dask/tests/test_order.py::test_order_doesnt_fail_on_mixed_type_keys[abcde] dask/tests/test_order.py::test_order_doesnt_fail_on_mixed_type_keys[edcba] dask/tests/test_order.py::test_gh_3055 dask/tests/test_order.py::test_type_comparisions_ok[abcde] dask/tests/test_order.py::test_type_comparisions_ok[edcba] dask/tests/test_order.py::test_prefer_short_dependents[abcde] dask/tests/test_order.py::test_prefer_short_dependents[edcba] dask/tests/test_order.py::test_local_parents_of_reduction[abcde] dask/tests/test_order.py::test_local_parents_of_reduction[edcba] dask/tests/test_order.py::test_nearest_neighbor[abcde] dask/tests/test_order.py::test_nearest_neighbor[edcba] dask/tests/test_order.py::test_string_ordering dask/tests/test_order.py::test_string_ordering_dependents dask/tests/test_order.py::test_prefer_short_narrow[abcde] dask/tests/test_order.py::test_prefer_short_narrow[edcba] dask/tests/test_order.py::test_prefer_short_ancestor[abcde] dask/tests/test_order.py::test_prefer_short_ancestor[edcba] dask/tests/test_order.py::test_map_overlap[abcde] dask/tests/test_order.py::test_map_overlap[edcba] dask/tests/test_order.py::test_use_structure_not_keys[abcde] dask/tests/test_order.py::test_use_structure_not_keys[edcba] dask/tests/test_order.py::test_dont_run_all_dependents_too_early[abcde] dask/tests/test_order.py::test_dont_run_all_dependents_too_early[edcba] dask/tests/test_order.py::test_many_branches_use_ndependencies[abcde] dask/tests/test_order.py::test_many_branches_use_ndependencies[edcba] dask/tests/test_order.py::test_order_cycle dask/tests/test_order.py::test_order_empty
dask/array/tests/test_array_core.py::test_Array_numpy_gufunc_call__array_ufunc__01 dask/array/tests/test_array_core.py::test_Array_numpy_gufunc_call__array_ufunc__02 dask/array/tests/test_array_core.py::test_no_warnings_from_blockwise dask/dataframe/io/tests/test_csv.py::test_categorical_dtypes dask/dataframe/io/tests/test_csv.py::test_categorical_known dask/dataframe/io/tests/test_csv.py::test_encoding_gh601[utf-16] dask/dataframe/io/tests/test_csv.py::test_encoding_gh601[utf-16-le] dask/dataframe/io/tests/test_demo.py::test_make_timeseries dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_non_numeric_dtypes dask/dataframe/tests/test_arithmetics_reduction.py::test_reductions_frame_dtypes dask/dataframe/tests/test_categorical.py::test_categorize dask/dataframe/tests/test_categorical.py::test_categorize_index dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[1-1] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[1-3] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[1-6] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[3-1] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[3-3] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[3-6] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[6-1] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[6-3] dask/dataframe/tests/test_categorical.py::test_categorical_set_index_npartitions_vs_ncategories[6-6] dask/dataframe/tests/test_categorical.py::test_repartition_on_categoricals[1] dask/dataframe/tests/test_categorical.py::test_repartition_on_categoricals[4] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_unknown_categories[series0] dask/dataframe/tests/test_categorical.py::TestCategoricalAccessor::test_unknown_categories[series1] dask/dataframe/tests/test_dataframe.py::test_timezone_freq[1] dask/dataframe/tests/test_dataframe.py::test_describe[None-None-None-subset1] dask/dataframe/tests/test_dataframe.py::test_describe[None-None-None-subset3] dask/dataframe/tests/test_dataframe.py::test_describe[None-None-None-subset4] dask/dataframe/tests/test_dataframe.py::test_describe[all-None-None-None] dask/dataframe/tests/test_dataframe.py::test_describe[include6-None-percentiles6-None] dask/dataframe/tests/test_dataframe.py::test_describe[include7-None-None-None] dask/dataframe/tests/test_dataframe.py::test_describe[include8-None-percentiles8-None] dask/dataframe/tests/test_dataframe.py::test_describe[None-exclude9-None-None] dask/dataframe/tests/test_dataframe.py::test_describe[include10-None-None-None] dask/dataframe/tests/test_dataframe.py::test_embarrassingly_parallel_operations dask/dataframe/tests/test_dataframe.py::test_to_timestamp dask/dataframe/tests/test_dataframe.py::test_apply_warns dask/dataframe/tests/test_dataframe.py::test_astype_categoricals dask/dataframe/tests/test_dataframe.py::test_astype_categoricals_known dask/dataframe/tests/test_dataframe.py::test_info dask/dataframe/tests/test_dataframe.py::test_groupby_multilevel_info dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx2-True] dask/dataframe/tests/test_dataframe.py::test_idxmaxmin[idx2-False] dask/dataframe/tests/test_dataframe.py::test_first_and_last[first] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-2-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-2-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-2-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-5-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-5-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[5-5-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-2-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-2-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-2-20] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-5-1] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-5-4] dask/dataframe/tests/test_dataframe.py::test_hash_split_unique[20-5-20] dask/dataframe/tests/test_dataframe.py::test_datetime_loc_open_slicing dask/dataframe/tests/test_dataframe.py::test_series_map[False-False-1-1] dask/dataframe/tests/test_dataframe.py::test_series_map[False-False-1-4] dask/dataframe/tests/test_dataframe.py::test_series_map[False-False-3-1] dask/dataframe/tests/test_dataframe.py::test_series_map[False-False-3-4] dask/dataframe/tests/test_dataframe.py::test_series_map[False-True-1-1] dask/dataframe/tests/test_dataframe.py::test_series_map[False-True-1-4] dask/dataframe/tests/test_dataframe.py::test_series_map[False-True-3-1] dask/dataframe/tests/test_dataframe.py::test_series_map[False-True-3-4] dask/dataframe/tests/test_dataframe.py::test_series_map[True-False-1-1] dask/dataframe/tests/test_dataframe.py::test_series_map[True-False-1-4] dask/dataframe/tests/test_dataframe.py::test_series_map[True-False-3-1] dask/dataframe/tests/test_dataframe.py::test_series_map[True-False-3-4] dask/dataframe/tests/test_dataframe.py::test_series_map[True-True-1-1] dask/dataframe/tests/test_dataframe.py::test_series_map[True-True-1-4] dask/dataframe/tests/test_dataframe.py::test_series_map[True-True-3-1] dask/dataframe/tests/test_dataframe.py::test_series_map[True-True-3-4] dask/dataframe/tests/test_format.py::test_repr_meta_mutation dask/dataframe/tests/test_format.py::test_categorical_format dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[cov-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>1] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>3] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>4] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>5] dask/dataframe/tests/test_groupby.py::test_groupby_multilevel_getitem[corr-<lambda>6] dask/dataframe/tests/test_groupby.py::test_groupby_index_array dask/dataframe/tests/test_groupby.py::test_split_apply_combine_on_series[True] dask/dataframe/tests/test_groupby.py::test_split_apply_combine_on_series[False] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[cov-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[cov-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[cov-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[cov-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[cov-<lambda>4] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[corr-<lambda>0] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[corr-<lambda>1] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[corr-<lambda>2] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[corr-<lambda>3] dask/dataframe/tests/test_groupby.py::test_dataframe_aggregations_multilevel[corr-<lambda>4] dask/dataframe/tests/test_groupby.py::test_std_object_dtype[<lambda>0] dask/dataframe/tests/test_groupby.py::test_groupby_cov[columns0] dask/dataframe/tests/test_groupby.py::test_groupby_cov[columns1] dask/dataframe/tests/test_groupby.py::test_groupby_cov[columns2] dask/dataframe/tests/test_groupby.py::test_groupby_cov[columns3] dask/dataframe/tests/test_groupby.py::test_groupby_value_counts dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj1] dask/dataframe/tests/test_hashing.py::test_hash_object_dispatch[obj6] dask/dataframe/tests/test_indexing.py::test_loc_with_text_dates dask/dataframe/tests/test_indexing.py::test_loc_on_numpy_datetimes dask/dataframe/tests/test_indexing.py::test_loc_on_pandas_datetimes dask/dataframe/tests/test_indexing.py::test_loc_datetime_no_freq dask/dataframe/tests/test_indexing.py::test_loc_timestamp_str dask/dataframe/tests/test_indexing.py::test_getitem_timestamp_str dask/dataframe/tests/test_indexing.py::test_getitem_period_str dask/dataframe/tests/test_multi.py::test_merge_asof_indexed dask/dataframe/tests/test_multi.py::test_merge_asof_on_basic dask/dataframe/tests/test_multi.py::test_merge_asof_on[backward-True] dask/dataframe/tests/test_multi.py::test_merge_asof_on[backward-False] dask/dataframe/tests/test_multi.py::test_merge_asof_on[forward-True] dask/dataframe/tests/test_multi.py::test_merge_asof_on[forward-False] dask/dataframe/tests/test_multi.py::test_merge_asof_on[nearest-True] dask/dataframe/tests/test_multi.py::test_merge_asof_on[nearest-False] dask/dataframe/tests/test_multi.py::test_concat_categorical_mixed_simple dask/dataframe/tests/test_multi.py::test_append_categorical dask/dataframe/tests/test_multi.py::test_merge_outer_empty dask/dataframe/tests/test_shuffle.py::test_partitioning_index_categorical_on_values dask/dataframe/tests/test_shuffle.py::test_set_index_timezone dask/dataframe/tests/test_shuffle.py::test_set_index_on_empty dask/dataframe/tests/test_shuffle.py::test_set_index_timestamp dask/dataframe/tests/test_ufunc.py::test_2args_with_array[pandas1-darray1-ldexp] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-conj-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-square-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-absolute-prod] dask/dataframe/tests/test_ufunc.py::test_ufunc_with_reduction[pandas1-negative-prod] dask/dataframe/tests/test_utils_dataframe.py::test_meta_nonempty
docs/source/graphs.rst docs/source/futures.rst dask/bag/core.py dask/dataframe/groupby.py dask/dataframe/core.py dask/dataframe/methods.py dask/dataframe/_compat.py dask/dataframe/io/parquet/arrow.py dask/array/core.py docs/source/custom-collections.rst dask/order.py dask/dataframe/multi.py dask/dataframe/utils.py
docs/source/graphs.rst docs/source/futures.rst dask/bag/core.py dask/dataframe/groupby.py dask/dataframe/core.py dask/dataframe/methods.py dask/dataframe/_compat.py dask/dataframe/io/parquet/arrow.py dask/array/core.py docs/source/custom-collections.rst dask/order.py dask/dataframe/multi.py dask/dataframe/utils.py