ceph/src/arrow/csharp/test/Apache.Arrow.Tests/ArrowBufferBuilderTests.cs

   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 }