# TODO move away from this test generator style since its we need to manage the generator file,
# which is no longer in this project workspace, as well as the output test file.
##                                                             ##
#                                                               #
#   THIS TEST WAS AUTOGENERATED BY groupby_test_generator.py    #
#                                                               #
##

import unittest

import pandas as pd

import riptable as rt

# TODO refactor this into table driven tests using pytest parameterize since each test body follows the same structure
# and a single test body with multiple test tabe entries will be more readable and flexible.
from .groupby_unit_test_parameters import *


class autogenerated_gb_tests(unittest.TestCase):
    def safe_assert(self, ary1, ary2):
        for a, b in zip(ary1, ary2):
            if a == a and b == b:
                self.assertAlmostEqual(a, b, places=7)

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["median"]
        test_class = groupby_everything(1, 1, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["median"]
        test_class = groupby_everything(4, 1, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["median"]
        test_class = groupby_everything(7, 1, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["median"]
        test_class = groupby_everything(2, 2, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["median"]
        test_class = groupby_everything(5, 2, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["median"]
        test_class = groupby_everything(1, 3, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["median"]
        test_class = groupby_everything(4, 3, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["median"]
        test_class = groupby_everything(7, 3, 0.1, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["median"]
        test_class = groupby_everything(2, 1, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["median"]
        test_class = groupby_everything(5, 1, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["median"]
        test_class = groupby_everything(1, 2, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["median"]
        test_class = groupby_everything(4, 2, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["median"]
        test_class = groupby_everything(7, 2, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["median"]
        test_class = groupby_everything(2, 3, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["median"]
        test_class = groupby_everything(5, 3, 0.30, ["median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(1, 1, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(4, 1, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(7, 1, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(2, 2, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(5, 2, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(1, 3, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(4, 3, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(7, 3, 0.1, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(2, 1, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(5, 1, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(1, 2, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(4, 2, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(7, 2, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(2, 3, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_median_min__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["median", "min"]
        test_class = groupby_everything(5, 3, 0.30, ["median", "min"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(1, 1, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(4, 1, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(7, 1, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(2, 2, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(5, 2, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(1, 3, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(4, 3, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(7, 3, 0.1, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(2, 1, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(5, 1, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(1, 2, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(4, 2, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(7, 2, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(2, 3, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_mean_max__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["var", "mean", "max"]
        test_class = groupby_everything(5, 3, 0.30, ["var", "mean", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_1__nkeycols_1(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(1, 1, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_4__nkeycols_1(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(4, 1, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_7__nkeycols_1(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(7, 1, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_2__nkeycols_2(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(2, 2, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_5__nkeycols_2(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(5, 2, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_1__nkeycols_3(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(1, 3, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_4__nkeycols_3(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(4, 3, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_01__nvalcols_7__nkeycols_3(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(7, 3, 0.1, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(2, 1, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(5, 1, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(1, 2, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(4, 2, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(7, 2, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(2, 3, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_max_sum_mean__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["var", "max", "sum", "mean"]
        test_class = groupby_everything(5, 3, 0.30, ["var", "max", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["max"]
        test_class = groupby_everything(1, 1, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["max"]
        test_class = groupby_everything(4, 1, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["max"]
        test_class = groupby_everything(7, 1, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["max"]
        test_class = groupby_everything(2, 2, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["max"]
        test_class = groupby_everything(5, 2, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["max"]
        test_class = groupby_everything(1, 3, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["max"]
        test_class = groupby_everything(4, 3, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["max"]
        test_class = groupby_everything(7, 3, 0.1, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["max"]
        test_class = groupby_everything(2, 1, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["max"]
        test_class = groupby_everything(5, 1, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["max"]
        test_class = groupby_everything(1, 2, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["max"]
        test_class = groupby_everything(4, 2, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["max"]
        test_class = groupby_everything(7, 2, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["max"]
        test_class = groupby_everything(2, 3, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["max"]
        test_class = groupby_everything(5, 3, 0.30, ["max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(1, 1, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(4, 1, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(7, 1, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(2, 2, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(5, 2, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(1, 3, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(4, 3, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(7, 3, 0.1, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(2, 1, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(5, 1, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(1, 2, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(4, 2, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(7, 2, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(2, 3, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_sum__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["min", "sum"]
        test_class = groupby_everything(5, 3, 0.30, ["min", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_1__nkeycols_1(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(1, 1, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_4__nkeycols_1(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(4, 1, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_7__nkeycols_1(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(7, 1, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_2__nkeycols_2(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(2, 2, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_5__nkeycols_2(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(5, 2, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_1__nkeycols_3(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(1, 3, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_4__nkeycols_3(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(4, 3, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_01__nvalcols_7__nkeycols_3(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(7, 3, 0.1, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(2, 1, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(5, 1, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(1, 2, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(4, 2, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(7, 2, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(2, 3, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var_median_sum__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["var", "median", "sum"]
        test_class = groupby_everything(5, 3, 0.30, ["var", "median", "sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_1__nkeycols_1(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(1, 1, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_4__nkeycols_1(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(4, 1, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_7__nkeycols_1(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(7, 1, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_2__nkeycols_2(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(2, 2, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_5__nkeycols_2(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(5, 2, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_1__nkeycols_3(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(1, 3, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_4__nkeycols_3(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(4, 3, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_01__nvalcols_7__nkeycols_3(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(7, 3, 0.1, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(2, 1, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(5, 1, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(1, 2, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(4, 2, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(7, 2, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(2, 3, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_max_median_mean_var__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["max", "median", "mean", "var"]
        test_class = groupby_everything(5, 3, 0.30, ["max", "median", "mean", "var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["sum"]
        test_class = groupby_everything(1, 1, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["sum"]
        test_class = groupby_everything(4, 1, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["sum"]
        test_class = groupby_everything(7, 1, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["sum"]
        test_class = groupby_everything(2, 2, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["sum"]
        test_class = groupby_everything(5, 2, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["sum"]
        test_class = groupby_everything(1, 3, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["sum"]
        test_class = groupby_everything(4, 3, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["sum"]
        test_class = groupby_everything(7, 3, 0.1, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["sum"]
        test_class = groupby_everything(2, 1, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["sum"]
        test_class = groupby_everything(5, 1, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["sum"]
        test_class = groupby_everything(1, 2, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["sum"]
        test_class = groupby_everything(4, 2, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["sum"]
        test_class = groupby_everything(7, 2, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["sum"]
        test_class = groupby_everything(2, 3, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["sum"]
        test_class = groupby_everything(5, 3, 0.30, ["sum"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(1, 1, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(4, 1, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(7, 1, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(2, 2, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(5, 2, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(1, 3, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(4, 3, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(7, 3, 0.1, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(2, 1, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(5, 1, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(1, 2, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(4, 2, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(7, 2, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(2, 3, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_max__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["min", "max"]
        test_class = groupby_everything(5, 3, 0.30, ["min", "max"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_1__nkeycols_1(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(1, 1, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_4__nkeycols_1(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(4, 1, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_7__nkeycols_1(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(7, 1, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_2__nkeycols_2(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(2, 2, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_5__nkeycols_2(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(5, 2, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_1__nkeycols_3(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(1, 3, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_4__nkeycols_3(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(4, 3, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_01__nvalcols_7__nkeycols_3(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(7, 3, 0.1, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(2, 1, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(5, 1, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(1, 2, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(4, 2, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(7, 2, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(2, 3, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_sum_var_median__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["sum", "var", "median"]
        test_class = groupby_everything(5, 3, 0.30, ["sum", "var", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_1__nkeycols_1(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(1, 1, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_4__nkeycols_1(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(4, 1, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_7__nkeycols_1(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(7, 1, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_2__nkeycols_2(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(2, 2, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_5__nkeycols_2(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(5, 2, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_1__nkeycols_3(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(1, 3, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_4__nkeycols_3(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(4, 3, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_01__nvalcols_7__nkeycols_3(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(7, 3, 0.1, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_2__nkeycols_1(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(2, 1, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_5__nkeycols_1(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(5, 1, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_1__nkeycols_2(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(1, 2, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_4__nkeycols_2(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(4, 2, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_7__nkeycols_2(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(7, 2, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_2__nkeycols_3(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(2, 3, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median_sum_mean__symb_ratio_0300__nvalcols_5__nkeycols_3(
        self,
    ):
        aggs = ["min", "median", "sum", "mean"]
        test_class = groupby_everything(5, 3, 0.30, ["min", "median", "sum", "mean"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["var"]
        test_class = groupby_everything(1, 1, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["var"]
        test_class = groupby_everything(4, 1, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["var"]
        test_class = groupby_everything(7, 1, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["var"]
        test_class = groupby_everything(2, 2, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["var"]
        test_class = groupby_everything(5, 2, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_1__nkeycols_3(self):
        aggs = ["var"]
        test_class = groupby_everything(1, 3, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_4__nkeycols_3(self):
        aggs = ["var"]
        test_class = groupby_everything(4, 3, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_01__nvalcols_7__nkeycols_3(self):
        aggs = ["var"]
        test_class = groupby_everything(7, 3, 0.1, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_2__nkeycols_1(self):
        aggs = ["var"]
        test_class = groupby_everything(2, 1, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_5__nkeycols_1(self):
        aggs = ["var"]
        test_class = groupby_everything(5, 1, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_1__nkeycols_2(self):
        aggs = ["var"]
        test_class = groupby_everything(1, 2, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_4__nkeycols_2(self):
        aggs = ["var"]
        test_class = groupby_everything(4, 2, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_7__nkeycols_2(self):
        aggs = ["var"]
        test_class = groupby_everything(7, 2, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_2__nkeycols_3(self):
        aggs = ["var"]
        test_class = groupby_everything(2, 3, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_var__symb_ratio_0300__nvalcols_5__nkeycols_3(self):
        aggs = ["var"]
        test_class = groupby_everything(5, 3, 0.30, ["var"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median__symb_ratio_01__nvalcols_1__nkeycols_1(self):
        aggs = ["min", "median"]
        test_class = groupby_everything(1, 1, 0.1, ["min", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median__symb_ratio_01__nvalcols_4__nkeycols_1(self):
        aggs = ["min", "median"]
        test_class = groupby_everything(4, 1, 0.1, ["min", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median__symb_ratio_01__nvalcols_7__nkeycols_1(self):
        aggs = ["min", "median"]
        test_class = groupby_everything(7, 1, 0.1, ["min", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median__symb_ratio_01__nvalcols_2__nkeycols_2(self):
        aggs = ["min", "median"]
        test_class = groupby_everything(2, 2, 0.1, ["min", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])

    def test_multikey___aggs_min_median__symb_ratio_01__nvalcols_5__nkeycols_2(self):
        aggs = ["min", "median"]
        test_class = groupby_everything(5, 2, 0.1, ["min", "median"])
        pd_out = (
            pd.DataFrame(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        sf_out = (
            rt.Dataset(test_class.data)
            .groupby(KEY_COLUMN_NAMES[: test_class.key_columns])
            .agg(test_class.aggregation_functions)
        )
        for func in aggs:
            for i in range(0, test_class.val_columns):
                column = VAL_COLUMN_NAMES[i]
                self.safe_assert(pd_out[column][func], sf_out[func.title()][column])


if __name__ == "__main__":
    tester = unittest.main()
