Skip to content

Commit 6e8bd08

Browse files
ttnghiattnghia
committed
Remove namespace
Signed-off-by: Nghia Truong <[email protected]>
1 parent 1e09a6b commit 6e8bd08

File tree

3 files changed

+102
-107
lines changed

3 files changed

+102
-107
lines changed

‎cpp/tests/groupby/groupby_test_util.cpp‎

Lines changed: 49 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -17,125 +17,124 @@
1717
#include <cudf/table/table.hpp>
1818
#include <cudf/types.hpp>
1919

20-
namespace cudf ::test {
21-
22-
void test_single_agg(column_view const& keys,
23-
column_view const& values,
24-
column_view const& expect_keys,
25-
column_view const& expect_vals,
26-
std::unique_ptr<groupby_aggregation>&& agg,
20+
void test_single_agg(cudf::column_view const& keys,
21+
cudf::column_view const& values,
22+
cudf::column_view const& expect_keys,
23+
cudf::column_view const& expect_vals,
24+
std::unique_ptr<cudf::groupby_aggregation>&& agg,
2725
force_use_sort_impl use_sort,
28-
null_policy include_null_keys,
29-
sorted keys_are_sorted,
30-
std::vector<order> const& column_order,
31-
std::vector<null_order> const& null_precedence,
32-
sorted reference_keys_are_sorted,
26+
cudf::null_policy include_null_keys,
27+
cudf::sorted keys_are_sorted,
28+
std::vector<cudf::order> const& column_order,
29+
std::vector<cudf::null_order> const& null_precedence,
30+
cudf::sorted reference_keys_are_sorted,
3331
std::source_location const& location)
3432
{
3533
SCOPED_TRACE("Original failure location: " + std::string{location.file_name()} + ":" +
3634
std::to_string(location.line()));
3735

3836
auto const [sorted_expect_keys, sorted_expect_vals] = [&]() {
39-
if (reference_keys_are_sorted == sorted::NO) {
37+
if (reference_keys_are_sorted == cudf::sorted::NO) {
4038
auto const sort_expect_order =
41-
sorted_order(table_view{{expect_keys}}, column_order, null_precedence);
42-
auto sorted_expect_keys = gather(table_view{{expect_keys}}, *sort_expect_order);
43-
auto sorted_expect_vals = gather(table_view{{expect_vals}}, *sort_expect_order);
39+
sorted_order(cudf::table_view{{expect_keys}}, column_order, null_precedence);
40+
auto sorted_expect_keys = gather(cudf::table_view{{expect_keys}}, *sort_expect_order);
41+
auto sorted_expect_vals = gather(cudf::table_view{{expect_vals}}, *sort_expect_order);
4442
return std::make_pair(std::move(sorted_expect_keys), std::move(sorted_expect_vals));
4543
}
46-
auto sorted_expect_keys = std::make_unique<table>(table_view{{expect_keys}});
47-
auto sorted_expect_vals = std::make_unique<table>(table_view{{expect_vals}});
44+
auto sorted_expect_keys = std::make_unique<cudf::table>(cudf::table_view{{expect_keys}});
45+
auto sorted_expect_vals = std::make_unique<cudf::table>(cudf::table_view{{expect_vals}});
4846
return std::make_pair(std::move(sorted_expect_keys), std::move(sorted_expect_vals));
4947
}();
5048

51-
std::vector<groupby::aggregation_request> requests;
49+
std::vector<cudf::groupby::aggregation_request> requests;
5250
requests.emplace_back();
5351
requests[0].values = values;
5452

5553
requests[0].aggregations.push_back(std::move(agg));
5654

5755
if (use_sort == force_use_sort_impl::YES) {
5856
// WAR to force groupby to use sort implementation
59-
requests[0].aggregations.push_back(make_nth_element_aggregation<groupby_aggregation>(0));
57+
requests[0].aggregations.push_back(
58+
cudf::make_nth_element_aggregation<cudf::groupby_aggregation>(0));
6059
}
6160

6261
// since the default behavior of groupby(...) for an empty null_precedence vector is
6362
// null_order::AFTER whereas for sorted_order(...) it's null_order::BEFORE
64-
auto const precedence =
65-
null_precedence.empty() ? std::vector<null_order>(1, null_order::BEFORE) : null_precedence;
63+
auto const precedence = null_precedence.empty()
64+
? std::vector<cudf::null_order>(1, cudf::null_order::BEFORE)
65+
: null_precedence;
6666

67-
groupby::groupby gb_obj(
68-
table_view({keys}), include_null_keys, keys_are_sorted, column_order, precedence);
67+
cudf::groupby::groupby gb_obj(
68+
cudf::table_view({keys}), include_null_keys, keys_are_sorted, column_order, precedence);
6969

70-
auto result = gb_obj.aggregate(requests, test::get_default_stream());
70+
auto result = gb_obj.aggregate(requests, cudf::test::get_default_stream());
7171

72-
if (use_sort == force_use_sort_impl::YES && keys_are_sorted == sorted::NO) {
72+
if (use_sort == force_use_sort_impl::YES && keys_are_sorted == cudf::sorted::NO) {
7373
CUDF_TEST_EXPECT_TABLES_EQUAL(*sorted_expect_keys, result.first->view());
7474
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(sorted_expect_vals->get_column(0),
7575
*result.second[0].results[0]);
7676

7777
} else {
7878
auto const sort_order = sorted_order(result.first->view(), column_order, precedence);
7979
auto const sorted_keys = gather(result.first->view(), *sort_order);
80-
auto const sorted_vals = gather(table_view({result.second[0].results[0]->view()}), *sort_order);
80+
auto const sorted_vals =
81+
gather(cudf::table_view({result.second[0].results[0]->view()}), *sort_order);
8182

8283
CUDF_TEST_EXPECT_TABLES_EQUAL(*sorted_expect_keys, *sorted_keys);
8384
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(sorted_expect_vals->get_column(0),
8485
sorted_vals->get_column(0));
8586
}
8687
}
8788

88-
void test_sum_agg(column_view const& keys,
89-
column_view const& values,
90-
column_view const& expected_keys,
91-
column_view const& expected_values,
89+
void test_sum_agg(cudf::column_view const& keys,
90+
cudf::column_view const& values,
91+
cudf::column_view const& expected_keys,
92+
cudf::column_view const& expected_values,
9293
std::source_location const& location)
9394
{
9495
auto const do_test = [&](auto const use_sort_option) {
9596
test_single_agg(keys,
9697
values,
9798
expected_keys,
9899
expected_values,
99-
make_sum_aggregation<groupby_aggregation>(),
100+
cudf::make_sum_aggregation<cudf::groupby_aggregation>(),
100101
use_sort_option,
101-
null_policy::INCLUDE,
102-
sorted::NO,
102+
cudf::null_policy::INCLUDE,
103+
cudf::sorted::NO,
103104
{},
104105
{},
105-
sorted::NO,
106+
cudf::sorted::NO,
106107
location);
107108
};
108109
do_test(force_use_sort_impl::YES);
109110
do_test(force_use_sort_impl::NO);
110111
}
111112

112-
void test_single_scan(column_view const& keys,
113-
column_view const& values,
114-
column_view const& expect_keys,
115-
column_view const& expect_vals,
116-
std::unique_ptr<groupby_scan_aggregation>&& agg,
117-
null_policy include_null_keys,
118-
sorted keys_are_sorted,
119-
std::vector<order> const& column_order,
120-
std::vector<null_order> const& null_precedence,
113+
void test_single_scan(cudf::column_view const& keys,
114+
cudf::column_view const& values,
115+
cudf::column_view const& expect_keys,
116+
cudf::column_view const& expect_vals,
117+
std::unique_ptr<cudf::groupby_scan_aggregation>&& agg,
118+
cudf::null_policy include_null_keys,
119+
cudf::sorted keys_are_sorted,
120+
std::vector<cudf::order> const& column_order,
121+
std::vector<cudf::null_order> const& null_precedence,
121122
std::source_location const& location)
122123
{
123124
SCOPED_TRACE("Original failure location: " + std::string{location.file_name()} + ":" +
124125
std::to_string(location.line()));
125126

126-
std::vector<groupby::scan_request> requests;
127+
std::vector<cudf::groupby::scan_request> requests;
127128
requests.emplace_back();
128129
requests[0].values = values;
129130
requests[0].aggregations.push_back(std::move(agg));
130131

131-
groupby::groupby gb_obj(
132-
table_view({keys}), include_null_keys, keys_are_sorted, column_order, null_precedence);
132+
cudf::groupby::groupby gb_obj(
133+
cudf::table_view({keys}), include_null_keys, keys_are_sorted, column_order, null_precedence);
133134

134135
// groupby scan uses sort implementation
135136
auto result = gb_obj.scan(requests);
136137

137-
CUDF_TEST_EXPECT_TABLES_EQUAL(table_view({expect_keys}), result.first->view());
138+
CUDF_TEST_EXPECT_TABLES_EQUAL(cudf::table_view({expect_keys}), result.first->view());
138139
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expect_vals, *result.second[0].results[0]);
139140
}
140-
141-
} // namespace cudf::test

‎cpp/tests/groupby/groupby_test_util.hpp‎

Lines changed: 24 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -12,35 +12,31 @@
1212

1313
enum class force_use_sort_impl : bool { NO, YES };
1414

15-
namespace cudf::test {
16-
17-
void test_single_agg(column_view const& keys,
18-
column_view const& values,
19-
column_view const& expect_keys,
20-
column_view const& expect_vals,
21-
std::unique_ptr<groupby_aggregation>&& agg,
22-
force_use_sort_impl use_sort = force_use_sort_impl::NO,
23-
null_policy include_null_keys = null_policy::EXCLUDE,
24-
sorted keys_are_sorted = sorted::NO,
25-
std::vector<order> const& column_order = {},
26-
std::vector<null_order> const& null_precedence = {},
27-
sorted reference_keys_are_sorted = sorted::NO,
15+
void test_single_agg(cudf::column_view const& keys,
16+
cudf::column_view const& values,
17+
cudf::column_view const& expect_keys,
18+
cudf::column_view const& expect_vals,
19+
std::unique_ptr<cudf::groupby_aggregation>&& agg,
20+
force_use_sort_impl use_sort = force_use_sort_impl::NO,
21+
cudf::null_policy include_null_keys = cudf::null_policy::EXCLUDE,
22+
cudf::sorted keys_are_sorted = cudf::sorted::NO,
23+
std::vector<cudf::order> const& column_order = {},
24+
std::vector<cudf::null_order> const& null_precedence = {},
25+
cudf::sorted reference_keys_are_sorted = cudf::sorted::NO,
2826
std::source_location const& location = std::source_location::current());
29-
void test_sum_agg(column_view const& keys,
30-
column_view const& values,
31-
column_view const& expected_keys,
32-
column_view const& expected_values,
27+
void test_sum_agg(cudf::column_view const& keys,
28+
cudf::column_view const& values,
29+
cudf::column_view const& expected_keys,
30+
cudf::column_view const& expected_values,
3331
std::source_location const& location = std::source_location::current());
3432

35-
void test_single_scan(column_view const& keys,
36-
column_view const& values,
37-
column_view const& expect_keys,
38-
column_view const& expect_vals,
39-
std::unique_ptr<groupby_scan_aggregation>&& agg,
40-
null_policy include_null_keys = null_policy::EXCLUDE,
41-
sorted keys_are_sorted = sorted::NO,
42-
std::vector<order> const& column_order = {},
43-
std::vector<null_order> const& null_precedence = {},
33+
void test_single_scan(cudf::column_view const& keys,
34+
cudf::column_view const& values,
35+
cudf::column_view const& expect_keys,
36+
cudf::column_view const& expect_vals,
37+
std::unique_ptr<cudf::groupby_scan_aggregation>&& agg,
38+
cudf::null_policy include_null_keys = cudf::null_policy::EXCLUDE,
39+
cudf::sorted keys_are_sorted = cudf::sorted::NO,
40+
std::vector<cudf::order> const& column_order = {},
41+
std::vector<cudf::null_order> const& null_precedence = {},
4442
std::source_location const& location = std::source_location::current());
45-
46-
} // namespace cudf::test

‎cpp/tests/groupby/rank_scan_tests.cpp‎

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
2+
* SPDX-FileCopyrightText: Copyright (c) 2021-2024, NVIDIA CORPORATION.
33
* SPDX-License-Identifier: Apache-2.0
44
*/
55

@@ -28,34 +28,34 @@ void test_rank_scans(cudf::column_view const& keys,
2828
cudf::column_view const& expected_rank,
2929
cudf::column_view const& expected_percent_rank)
3030
{
31-
cudf::test::test_single_scan(keys,
32-
order,
33-
keys,
34-
expected_dense,
35-
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
36-
cudf::rank_method::DENSE, {}, cudf::null_policy::INCLUDE),
37-
cudf::null_policy::INCLUDE,
38-
cudf::sorted::YES);
39-
cudf::test::test_single_scan(keys,
40-
order,
41-
keys,
42-
expected_rank,
43-
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
44-
cudf::rank_method::MIN, {}, cudf::null_policy::INCLUDE),
45-
cudf::null_policy::INCLUDE,
46-
cudf::sorted::YES);
47-
cudf::test::test_single_scan(keys,
48-
order,
49-
keys,
50-
expected_percent_rank,
51-
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
52-
cudf::rank_method::MIN,
53-
{},
54-
cudf::null_policy::INCLUDE,
55-
{},
56-
cudf::rank_percentage::ONE_NORMALIZED),
57-
cudf::null_policy::INCLUDE,
58-
cudf::sorted::YES);
31+
test_single_scan(keys,
32+
order,
33+
keys,
34+
expected_dense,
35+
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
36+
cudf::rank_method::DENSE, {}, cudf::null_policy::INCLUDE),
37+
cudf::null_policy::INCLUDE,
38+
cudf::sorted::YES);
39+
test_single_scan(keys,
40+
order,
41+
keys,
42+
expected_rank,
43+
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
44+
cudf::rank_method::MIN, {}, cudf::null_policy::INCLUDE),
45+
cudf::null_policy::INCLUDE,
46+
cudf::sorted::YES);
47+
test_single_scan(keys,
48+
order,
49+
keys,
50+
expected_percent_rank,
51+
cudf::make_rank_aggregation<cudf::groupby_scan_aggregation>(
52+
cudf::rank_method::MIN,
53+
{},
54+
cudf::null_policy::INCLUDE,
55+
{},
56+
cudf::rank_percentage::ONE_NORMALIZED),
57+
cudf::null_policy::INCLUDE,
58+
cudf::sorted::YES);
5959
}
6060

6161
struct groupby_rank_scan_test : public cudf::test::BaseFixture {};

0 commit comments

Comments
 (0)