]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | // Licensed to the Apache Software Foundation (ASF) under one or more |
2 | // contributor license agreements. See the NOTICE file distributed with | |
3 | // this work for additional information regarding copyright ownership. | |
4 | // The ASF licenses this file to You under the Apache License, Version 2.0 | |
5 | // (the "License"); you may not use this file except in compliance with | |
6 | // the License. You may obtain a copy of the License at | |
7 | // | |
8 | // http://www.apache.org/licenses/LICENSE-2.0 | |
9 | // | |
10 | // Unless required by applicable law or agreed to in writing, software | |
11 | // distributed under the License is distributed on an "AS IS" BASIS, | |
12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | // See the License for the specific language governing permissions and | |
14 | // limitations under the License. | |
15 | ||
16 | using System; | |
17 | using System.Linq; | |
18 | using Xunit; | |
19 | ||
20 | namespace Apache.Arrow.Tests | |
21 | { | |
22 | public class ArrowBufferBuilderTests | |
23 | { | |
24 | [Fact] | |
25 | public void ThrowsWhenIndexOutOfBounds() | |
26 | { | |
27 | Assert.Throws<IndexOutOfRangeException>(() => | |
28 | { | |
29 | var builder = new ArrowBuffer.Builder<int>(); | |
30 | builder.Span[100] = 100; | |
31 | }); | |
32 | } | |
33 | ||
34 | public class Append | |
35 | { | |
36 | [Fact] | |
37 | public void DoesNotThrowWithNullParameters() | |
38 | { | |
39 | var builder = new ArrowBuffer.Builder<int>(); | |
40 | ||
41 | builder.AppendRange(null); | |
42 | } | |
43 | ||
44 | [Fact] | |
45 | public void CapacityOnlyGrowsWhenLengthWillExceedCapacity() | |
46 | { | |
47 | var builder = new ArrowBuffer.Builder<int>(1); | |
48 | var capacity = builder.Capacity; | |
49 | ||
50 | builder.Append(1); | |
51 | ||
52 | Assert.Equal(capacity, builder.Capacity); | |
53 | } | |
54 | ||
55 | [Fact] | |
56 | public void CapacityGrowsAfterAppendWhenLengthExceedsCapacity() | |
57 | { | |
58 | var builder = new ArrowBuffer.Builder<int>(1); | |
59 | var capacity = builder.Capacity; | |
60 | ||
61 | builder.Append(1); | |
62 | builder.Append(2); | |
63 | ||
64 | Assert.True(builder.Capacity > capacity); | |
65 | } | |
66 | ||
67 | [Fact] | |
68 | public void CapacityGrowsAfterAppendSpan() | |
69 | { | |
70 | var builder = new ArrowBuffer.Builder<int>(1); | |
71 | var capacity = builder.Capacity; | |
72 | var data = Enumerable.Range(0, 10).Select(x => x).ToArray(); | |
73 | ||
74 | builder.Append(data); | |
75 | ||
76 | Assert.True(builder.Capacity > capacity); | |
77 | } | |
78 | ||
79 | [Fact] | |
80 | public void LengthIncrementsAfterAppend() | |
81 | { | |
82 | var builder = new ArrowBuffer.Builder<int>(1); | |
83 | var length = builder.Length; | |
84 | ||
85 | builder.Append(1); | |
86 | ||
87 | Assert.Equal(length + 1, builder.Length); | |
88 | } | |
89 | ||
90 | [Fact] | |
91 | public void LengthGrowsBySpanLength() | |
92 | { | |
93 | var builder = new ArrowBuffer.Builder<int>(1); | |
94 | var data = Enumerable.Range(0, 10).Select(x => x).ToArray(); | |
95 | ||
96 | builder.Append(data); | |
97 | ||
98 | Assert.Equal(10, builder.Length); | |
99 | } | |
100 | ||
101 | [Fact] | |
102 | public void BufferHasExpectedValues() | |
103 | { | |
104 | var builder = new ArrowBuffer.Builder<int>(1); | |
105 | ||
106 | builder.Append(10); | |
107 | builder.Append(20); | |
108 | ||
109 | var buffer = builder.Build(); | |
110 | var span = buffer.Span.CastTo<int>(); | |
111 | ||
112 | Assert.Equal(10, span[0]); | |
113 | Assert.Equal(20, span[1]); | |
114 | Assert.Equal(0, span[2]); | |
115 | } | |
116 | } | |
117 | ||
118 | public class AppendRange | |
119 | { | |
120 | [Fact] | |
121 | public void CapacityGrowsAfterAppendEnumerable() | |
122 | { | |
123 | var builder = new ArrowBuffer.Builder<int>(1); | |
124 | var capacity = builder.Capacity; | |
125 | var data = Enumerable.Range(0, 10).Select(x => x); | |
126 | ||
127 | builder.AppendRange(data); | |
128 | ||
129 | Assert.True(builder.Capacity > capacity); | |
130 | } | |
131 | ||
132 | [Fact] | |
133 | public void LengthGrowsByEnumerableCount() | |
134 | { | |
135 | var builder = new ArrowBuffer.Builder<int>(1); | |
136 | var length = builder.Length; | |
137 | var data = Enumerable.Range(0, 10).Select(x => x).ToArray(); | |
138 | var count = data.Length; | |
139 | ||
140 | builder.AppendRange(data); | |
141 | ||
142 | Assert.Equal(length + count, builder.Length); | |
143 | } | |
144 | ||
145 | [Fact] | |
146 | public void BufferHasExpectedValues() | |
147 | { | |
148 | var builder = new ArrowBuffer.Builder<int>(1); | |
149 | var data = Enumerable.Range(0, 10).Select(x => x).ToArray(); | |
150 | ||
151 | builder.AppendRange(data); | |
152 | ||
153 | var buffer = builder.Build(); | |
154 | var span = buffer.Span.CastTo<int>(); | |
155 | ||
156 | for (var i = 0; i < 10; i++) | |
157 | { | |
158 | Assert.Equal(i, span[i]); | |
159 | } | |
160 | } | |
161 | } | |
162 | ||
163 | public class Clear | |
164 | { | |
165 | [Theory] | |
166 | [InlineData(10)] | |
167 | [InlineData(100)] | |
168 | public void SetsAllValuesToDefault(int sizeBeforeClear) | |
169 | { | |
170 | var builder = new ArrowBuffer.Builder<int>(1); | |
171 | var data = Enumerable.Range(0, sizeBeforeClear).Select(x => x).ToArray(); | |
172 | ||
173 | builder.AppendRange(data); | |
174 | builder.Clear(); | |
175 | builder.Append(0); | |
176 | ||
177 | var buffer = builder.Build(); | |
178 | // No matter the sizeBeforeClear, we only appended a single 0, | |
179 | // so the buffer length should be the smallest possible. | |
180 | Assert.Equal(64, buffer.Length); | |
181 | ||
182 | // check all 16 int elements are default | |
183 | var zeros = Enumerable.Range(0, 16).Select(x => 0).ToArray(); | |
184 | var values = buffer.Span.CastTo<int>().Slice(0, 16).ToArray(); | |
185 | ||
186 | Assert.True(zeros.SequenceEqual(values)); | |
187 | } | |
188 | } | |
189 | ||
190 | public class Resize | |
191 | { | |
192 | [Fact] | |
193 | public void LengthHasExpectedValueAfterResize() | |
194 | { | |
195 | var builder = new ArrowBuffer.Builder<int>(); | |
196 | builder.Resize(8); | |
197 | ||
198 | Assert.True(builder.Capacity >= 8); | |
199 | Assert.Equal(8, builder.Length); | |
200 | } | |
201 | ||
202 | [Fact] | |
203 | public void NegativeLengthThrows() | |
204 | { | |
205 | // Arrange | |
206 | var builder = new ArrowBuffer.Builder<int>(); | |
207 | builder.Append(10); | |
208 | builder.Append(20); | |
209 | ||
210 | // Act/Assert | |
211 | Assert.Throws<ArgumentOutOfRangeException>(() => builder.Resize(-1)); | |
212 | } | |
213 | } | |
214 | ||
215 | } | |
216 | } |