Skip to content

Commit 4c73e68

Browse files
junli1026junli1026
committed
Change code license and format code
1 parent c72b537 commit 4c73e68

File tree

3 files changed

+149
-119
lines changed

3 files changed

+149
-119
lines changed

‎common/datavalues/src/arrays/builders/boolean_test.rs

+53-43
Original file line numberDiff line numberDiff line change
@@ -1,68 +1,78 @@
1-
// Copyright 2020-2021 The Datafuse Authors.
1+
// Copyright 2020 Datafuse Labs.
22
//
3-
// SPDX-License-Identifier: Apache-2.0.
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
414

515
use crate::prelude::*;
616

717
#[test]
818
fn test_empty_boolean_array() {
9-
let mut builder = BooleanArrayBuilder::with_capacity(16);
10-
let data_array: DataArray<BooleanType> = builder.finish();
11-
let mut iter = data_array.into_iter();
12-
assert_eq!(None, iter.next());
13-
assert_eq!(true, data_array.is_empty());
14-
assert_eq!(DataType::Boolean, data_array.data_type());
19+
let mut builder = BooleanArrayBuilder::with_capacity(16);
20+
let data_array: DataArray<BooleanType> = builder.finish();
21+
let mut iter = data_array.into_iter();
22+
assert_eq!(None, iter.next());
23+
assert_eq!(true, data_array.is_empty());
24+
assert_eq!(DataType::Boolean, data_array.data_type());
1525
}
1626

1727
#[test]
1828
fn test_fill_data() {
19-
let mut builder = BooleanArrayBuilder::with_capacity(16);
20-
builder.append_value(true);
21-
builder.append_value(false);
22-
builder.append_null();
23-
builder.append_option(Some(false));
24-
builder.append_option(None);
29+
let mut builder = BooleanArrayBuilder::with_capacity(16);
30+
builder.append_value(true);
31+
builder.append_value(false);
32+
builder.append_null();
33+
builder.append_option(Some(false));
34+
builder.append_option(None);
2535

26-
let data_array: DataArray<BooleanType> = builder.finish();
27-
let mut iter = data_array.into_iter();
36+
let data_array: DataArray<BooleanType> = builder.finish();
37+
let mut iter = data_array.into_iter();
2838

29-
assert_eq!(Some(Some(true)), iter.next());
30-
assert_eq!(Some(Some(false)), iter.next());
31-
assert_eq!(Some(None), iter.next());
32-
assert_eq!(Some(Some(false)), iter.next());
33-
assert_eq!(Some(None), iter.next());
34-
assert_eq!(None, iter.next());
39+
assert_eq!(Some(Some(true)), iter.next());
40+
assert_eq!(Some(Some(false)), iter.next());
41+
assert_eq!(Some(None), iter.next());
42+
assert_eq!(Some(Some(false)), iter.next());
43+
assert_eq!(Some(None), iter.next());
44+
assert_eq!(None, iter.next());
3545
}
3646

3747
#[test]
3848
fn test_new_from_slice() {
39-
let data_array: DataArray<BooleanType> = NewDataArray::new_from_slice(&[true, false]);
40-
let mut iter = data_array.into_iter();
41-
assert_eq!(Some(Some(true)), iter.next());
42-
assert_eq!(Some(Some(false)), iter.next());
43-
assert_eq!(None, iter.next());
49+
let data_array: DataArray<BooleanType> = NewDataArray::new_from_slice(&[true, false]);
50+
let mut iter = data_array.into_iter();
51+
assert_eq!(Some(Some(true)), iter.next());
52+
assert_eq!(Some(Some(false)), iter.next());
53+
assert_eq!(None, iter.next());
4454
}
4555

4656
#[test]
4757
fn test_new_from_opt_slice() {
48-
let v = [Some(true), Some(false), None];
49-
let data_array: DataArray<BooleanType> = NewDataArray::new_from_opt_slice(&v);
50-
let mut iter = data_array.into_iter();
51-
assert_eq!(Some(Some(true)), iter.next());
52-
assert_eq!(Some(Some(false)), iter.next());
53-
assert_eq!(Some(None), iter.next());
54-
assert_eq!(None, iter.next());
58+
let v = [Some(true), Some(false), None];
59+
let data_array: DataArray<BooleanType> = NewDataArray::new_from_opt_slice(&v);
60+
let mut iter = data_array.into_iter();
61+
assert_eq!(Some(Some(true)), iter.next());
62+
assert_eq!(Some(Some(false)), iter.next());
63+
assert_eq!(Some(None), iter.next());
64+
assert_eq!(None, iter.next());
5565
}
5666

5767
#[test]
5868
fn test_new_from_opt_iter() {
59-
let v = vec![None, Some(true), Some(false), None];
60-
let mut iter = v.into_iter();
61-
iter.next(); // move iterator and create data_array from second element
62-
let data_array: DataArray<BooleanType> = NewDataArray::new_from_opt_iter(iter);
63-
let mut iter = data_array.into_iter();
64-
assert_eq!(Some(Some(true)), iter.next());
65-
assert_eq!(Some(Some(false)), iter.next());
66-
assert_eq!(Some(None), iter.next());
67-
assert_eq!(None, iter.next());
69+
let v = vec![None, Some(true), Some(false), None];
70+
let mut iter = v.into_iter();
71+
iter.next(); // move iterator and create data_array from second element
72+
let data_array: DataArray<BooleanType> = NewDataArray::new_from_opt_iter(iter);
73+
let mut iter = data_array.into_iter();
74+
assert_eq!(Some(Some(true)), iter.next());
75+
assert_eq!(Some(Some(false)), iter.next());
76+
assert_eq!(Some(None), iter.next());
77+
assert_eq!(None, iter.next());
6878
}

‎common/datavalues/src/arrays/builders/primitive_test.rs

+51-41
Original file line numberDiff line numberDiff line change
@@ -1,70 +1,80 @@
1-
// Copyright 2020-2021 The Datafuse Authors.
1+
// Copyright 2020 Datafuse Labs.
22
//
3-
// SPDX-License-Identifier: Apache-2.0.
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
414

515
use crate::prelude::*;
616

717
#[test]
818
fn test_empty_array() {
9-
let mut builder = PrimitiveArrayBuilder::<Int64Type>::with_capacity(16);
10-
let data_array = builder.finish();
19+
let mut builder = PrimitiveArrayBuilder::<Int64Type>::with_capacity(16);
20+
let data_array = builder.finish();
1121

12-
// verify empty data array and data type
13-
assert_eq!(true, data_array.is_empty());
14-
assert_eq!(DataType::Int64, data_array.data_type());
22+
// verify empty data array and data type
23+
assert_eq!(true, data_array.is_empty());
24+
assert_eq!(DataType::Int64, data_array.data_type());
1525
}
1626

1727
#[test]
1828
fn test_fill_data() {
19-
let mut builder = PrimitiveArrayBuilder::<Int64Type>::with_capacity(16);
20-
builder.append_value(1);
21-
builder.append_option(Some(2));
22-
builder.append_null();
29+
let mut builder = PrimitiveArrayBuilder::<Int64Type>::with_capacity(16);
30+
builder.append_value(1);
31+
builder.append_option(Some(2));
32+
builder.append_null();
2333

24-
let data_array: DataArray<Int64Type> = builder.finish();
25-
let mut iter = data_array.into_iter();
34+
let data_array: DataArray<Int64Type> = builder.finish();
35+
let mut iter = data_array.into_iter();
2636

27-
// verify data array with value, option value and null
28-
assert_eq!(Some(Some(1)), iter.next());
29-
assert_eq!(Some(Some(2)), iter.next());
30-
assert_eq!(Some(None), iter.next());
31-
assert_eq!(None, iter.next());
37+
// verify data array with value, option value and null
38+
assert_eq!(Some(Some(1)), iter.next());
39+
assert_eq!(Some(Some(2)), iter.next());
40+
assert_eq!(Some(None), iter.next());
41+
assert_eq!(None, iter.next());
3242
}
3343

3444
#[test]
3545
fn test_new_from_slice() {
36-
let data_array: DataArray<Int64Type> = NewDataArray::new_from_slice(&[1, 2]);
37-
let mut iter = data_array.into_iter();
46+
let data_array: DataArray<Int64Type> = NewDataArray::new_from_slice(&[1, 2]);
47+
let mut iter = data_array.into_iter();
3848

39-
// verify NewDataArray::new_from_slice
40-
assert_eq!(Some(Some(1)), iter.next());
41-
assert_eq!(Some(Some(2)), iter.next());
42-
assert_eq!(None, iter.next());
49+
// verify NewDataArray::new_from_slice
50+
assert_eq!(Some(Some(1)), iter.next());
51+
assert_eq!(Some(Some(2)), iter.next());
52+
assert_eq!(None, iter.next());
4353
}
4454

4555
#[test]
4656
fn test_new_from_opt_slice() {
47-
let v = [Some(1), Some(2), None];
48-
let data_array: DataArray<Int64Type> = NewDataArray::new_from_opt_slice(&v);
49-
let mut iter = data_array.into_iter();
57+
let v = [Some(1), Some(2), None];
58+
let data_array: DataArray<Int64Type> = NewDataArray::new_from_opt_slice(&v);
59+
let mut iter = data_array.into_iter();
5060

51-
// verify NewDataArray::new_from_opt_slice
52-
assert_eq!(Some(Some(1)), iter.next());
53-
assert_eq!(Some(Some(2)), iter.next());
54-
assert_eq!(Some(None), iter.next());
55-
assert_eq!(None, iter.next());
61+
// verify NewDataArray::new_from_opt_slice
62+
assert_eq!(Some(Some(1)), iter.next());
63+
assert_eq!(Some(Some(2)), iter.next());
64+
assert_eq!(Some(None), iter.next());
65+
assert_eq!(None, iter.next());
5666
}
5767

5868
#[test]
5969
fn test_new_from_opt_iter() {
60-
let v = vec![None, Some(1), Some(2), None];
61-
let mut iter = v.into_iter();
62-
iter.next(); // move iterator and create data_array from second element
63-
let data_array: DataArray<Int64Type> = NewDataArray::new_from_opt_iter(iter);
64-
let mut iter = data_array.into_iter();
70+
let v = vec![None, Some(1), Some(2), None];
71+
let mut iter = v.into_iter();
72+
iter.next(); // move iterator and create data_array from second element
73+
let data_array: DataArray<Int64Type> = NewDataArray::new_from_opt_iter(iter);
74+
let mut iter = data_array.into_iter();
6575

66-
assert_eq!(Some(Some(1)), iter.next());
67-
assert_eq!(Some(Some(2)), iter.next());
68-
assert_eq!(Some(None), iter.next());
69-
assert_eq!(None, iter.next());
76+
assert_eq!(Some(Some(1)), iter.next());
77+
assert_eq!(Some(Some(2)), iter.next());
78+
assert_eq!(Some(None), iter.next());
79+
assert_eq!(None, iter.next());
7080
}

‎common/datavalues/src/arrays/builders/utf8_test.rs

+45-35
Original file line numberDiff line numberDiff line change
@@ -1,55 +1,65 @@
1-
// Copyright 2020-2021 The Datafuse Authors.
1+
// Copyright 2020 Datafuse Labs.
22
//
3-
// SPDX-License-Identifier: Apache-2.0.
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
414

515
use crate::prelude::*;
616

717
#[test]
818
fn test_empty_array() {
9-
let mut builder = Utf8ArrayBuilder::with_capacity(16);
10-
let data_array = builder.finish();
11-
assert_eq!(true, data_array.is_empty());
12-
assert_eq!(DataType::Utf8, data_array.data_type());
19+
let mut builder = Utf8ArrayBuilder::with_capacity(16);
20+
let data_array = builder.finish();
21+
assert_eq!(true, data_array.is_empty());
22+
assert_eq!(DataType::Utf8, data_array.data_type());
1323
}
1424

1525
#[test]
1626
fn test_fill_data() {
17-
let mut builder = Utf8ArrayBuilder::with_capacity(16);
18-
builder.append_value("你好");
19-
builder.append_option(Some("\u{1F378}"));
20-
builder.append_null();
21-
22-
let data_array: DataArray<Utf8Type> = builder.finish();
23-
let mut iter = data_array.into_iter();
24-
25-
assert_eq!(3, data_array.len());
26-
assert_eq!(Some(Some("你好")), iter.next());
27-
assert_eq!(Some(Some("🍸")), iter.next());
28-
assert_eq!(Some(None), iter.next());
29-
assert_eq!(None, iter.next());
27+
let mut builder = Utf8ArrayBuilder::with_capacity(16);
28+
builder.append_value("你好");
29+
builder.append_option(Some("\u{1F378}"));
30+
builder.append_null();
31+
32+
let data_array: DataArray<Utf8Type> = builder.finish();
33+
let mut iter = data_array.into_iter();
34+
35+
assert_eq!(3, data_array.len());
36+
assert_eq!(Some(Some("你好")), iter.next());
37+
assert_eq!(Some(Some("🍸")), iter.next());
38+
assert_eq!(Some(None), iter.next());
39+
assert_eq!(None, iter.next());
3040
}
3141

3242
#[test]
3343
fn test_new_from_opt_slice() {
34-
let data_array: DataArray<Utf8Type> = DataArray::new_from_opt_slice(&[Some("你好"), None]);
35-
let mut iter = data_array.into_iter();
44+
let data_array: DataArray<Utf8Type> = DataArray::new_from_opt_slice(&[Some("你好"), None]);
45+
let mut iter = data_array.into_iter();
3646

37-
assert_eq!(2, data_array.len());
38-
assert_eq!(Some(Some("你好")), iter.next());
39-
assert_eq!(Some(None), iter.next());
40-
assert_eq!(None, iter.next());
47+
assert_eq!(2, data_array.len());
48+
assert_eq!(Some(Some("你好")), iter.next());
49+
assert_eq!(Some(None), iter.next());
50+
assert_eq!(None, iter.next());
4151
}
4252

4353
#[test]
4454
fn test_new_from_opt_iter() {
45-
let v = vec![None, Some("你好"), None];
46-
let mut iter = v.into_iter();
47-
iter.next(); // move iterator and create data array from second element
48-
let data_array: DataArray<Utf8Type> = DataArray::new_from_opt_iter(iter);
49-
let mut iter = data_array.into_iter();
50-
51-
assert_eq!(2, data_array.len());
52-
assert_eq!(Some(Some("你好")), iter.next());
53-
assert_eq!(Some(None), iter.next());
54-
assert_eq!(None, iter.next());
55+
let v = vec![None, Some("你好"), None];
56+
let mut iter = v.into_iter();
57+
iter.next(); // move iterator and create data array from second element
58+
let data_array: DataArray<Utf8Type> = DataArray::new_from_opt_iter(iter);
59+
let mut iter = data_array.into_iter();
60+
61+
assert_eq!(2, data_array.len());
62+
assert_eq!(Some(Some("你好")), iter.next());
63+
assert_eq!(Some(None), iter.next());
64+
assert_eq!(None, iter.next());
5565
}

0 commit comments

Comments
 (0)