Skip to content

Commit 02f498a

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

File tree

3 files changed

+110
-114
lines changed

3 files changed

+110
-114
lines changed

‎cpp/tests/groupby/groupby_test_util.cpp‎

Lines changed: 57 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -17,125 +17,125 @@
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+
cudf::sorted_order(cudf::table_view{{expect_keys}}, column_order, null_precedence);
40+
auto sorted_expect_keys = cudf::gather(cudf::table_view{{expect_keys}}, *sort_expect_order);
41+
auto sorted_expect_vals = cudf::gather(cudf::table_view{{expect_vals}}, *sort_expect_order);
42+
return std::make_pair(std::move(sorted_expect_keys), std::move(sorted_expect_vals));
43+
} else {
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}});
4446
return std::make_pair(std::move(sorted_expect_keys), std::move(sorted_expect_vals));
4547
}
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}});
48-
return std::make_pair(std::move(sorted_expect_keys), std::move(sorted_expect_vals));
4948
}();
5049

51-
std::vector<groupby::aggregation_request> requests;
50+
std::vector<cudf::groupby::aggregation_request> requests;
5251
requests.emplace_back();
5352
requests[0].values = values;
5453

5554
requests[0].aggregations.push_back(std::move(agg));
5655

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

62-
// since the default behavior of groupby(...) for an empty null_precedence vector is
63-
// 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;
62+
// since the default behavior of cudf::groupby(...) for an empty null_precedence vector is
63+
// null_order::AFTER whereas for cudf::sorted_order(...) it's null_order::BEFORE
64+
auto const precedence = null_precedence.empty()
65+
? std::vector<cudf::null_order>(1, cudf::null_order::BEFORE)
66+
: null_precedence;
6667

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

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

72-
if (use_sort == force_use_sort_impl::YES && keys_are_sorted == sorted::NO) {
73+
if (use_sort == force_use_sort_impl::YES && keys_are_sorted == cudf::sorted::NO) {
7374
CUDF_TEST_EXPECT_TABLES_EQUAL(*sorted_expect_keys, result.first->view());
7475
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(sorted_expect_vals->get_column(0),
7576
*result.second[0].results[0]);
7677

7778
} else {
78-
auto const sort_order = sorted_order(result.first->view(), column_order, precedence);
79-
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);
79+
auto const sort_order = cudf::sorted_order(result.first->view(), column_order, precedence);
80+
auto const sorted_keys = cudf::gather(result.first->view(), *sort_order);
81+
auto const sorted_vals =
82+
cudf::gather(cudf::table_view({result.second[0].results[0]->view()}), *sort_order);
8183

8284
CUDF_TEST_EXPECT_TABLES_EQUAL(*sorted_expect_keys, *sorted_keys);
8385
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(sorted_expect_vals->get_column(0),
8486
sorted_vals->get_column(0));
8587
}
8688
}
8789

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,
90+
void test_sum_agg(cudf::column_view const& keys,
91+
cudf::column_view const& values,
92+
cudf::column_view const& expected_keys,
93+
cudf::column_view const& expected_values,
9294
std::source_location const& location)
9395
{
9496
auto const do_test = [&](auto const use_sort_option) {
9597
test_single_agg(keys,
9698
values,
9799
expected_keys,
98100
expected_values,
99-
make_sum_aggregation<groupby_aggregation>(),
101+
cudf::make_sum_aggregation<cudf::groupby_aggregation>(),
100102
use_sort_option,
101-
null_policy::INCLUDE,
102-
sorted::NO,
103+
cudf::null_policy::INCLUDE,
104+
cudf::sorted::NO,
103105
{},
104106
{},
105-
sorted::NO,
107+
cudf::sorted::NO,
106108
location);
107109
};
108110
do_test(force_use_sort_impl::YES);
109111
do_test(force_use_sort_impl::NO);
110112
}
111113

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,
114+
void test_single_scan(cudf::column_view const& keys,
115+
cudf::column_view const& values,
116+
cudf::column_view const& expect_keys,
117+
cudf::column_view const& expect_vals,
118+
std::unique_ptr<cudf::groupby_scan_aggregation>&& agg,
119+
cudf::null_policy include_null_keys,
120+
cudf::sorted keys_are_sorted,
121+
std::vector<cudf::order> const& column_order,
122+
std::vector<cudf::null_order> const& null_precedence,
121123
std::source_location const& location)
122124
{
123125
SCOPED_TRACE("Original failure location: " + std::string{location.file_name()} + ":" +
124126
std::to_string(location.line()));
125127

126-
std::vector<groupby::scan_request> requests;
128+
std::vector<cudf::groupby::scan_request> requests;
127129
requests.emplace_back();
128130
requests[0].values = values;
129131
requests[0].aggregations.push_back(std::move(agg));
130132

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

134-
// groupby scan uses sort implementation
136+
// cudf::groupby scan uses sort implementation
135137
auto result = gb_obj.scan(requests);
136138

137-
CUDF_TEST_EXPECT_TABLES_EQUAL(table_view({expect_keys}), result.first->view());
139+
CUDF_TEST_EXPECT_TABLES_EQUAL(cudf::table_view({expect_keys}), result.first->view());
138140
CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expect_vals, *result.second[0].results[0]);
139141
}
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)