src/third_party/WebKit/Source/wtf/ArrayBufferBuilderTest.cpp

   1 /*
   2  * Copyright (C) 2013 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "wtf/ArrayBufferBuilder.h"
  33
  34 #include "wtf/Assertions.h"
  35 #include <gtest/gtest.h>
  36 #include <string.h>
  37
  38 namespace WTF {
  39
  40 TEST(ArrayBufferBuilder, Constructor)
  41 {
  42     ArrayBufferBuilder zeroBuilder(0);
  43     EXPECT_EQ(0u, zeroBuilder.byteLength());
  44     EXPECT_EQ(0u, zeroBuilder.capacity());
  45
  46     ArrayBufferBuilder smallBuilder(1024);
  47     EXPECT_EQ(0u, zeroBuilder.byteLength());
  48     EXPECT_EQ(1024u, smallBuilder.capacity());
  49
  50     ArrayBufferBuilder bigBuilder(2048);
  51     EXPECT_EQ(0u, zeroBuilder.byteLength());
  52     EXPECT_EQ(2048u, bigBuilder.capacity());
  53 }
  54
  55 TEST(ArrayBufferBuilder, Append)
  56 {
  57     const char data[] = "HelloWorld";
  58     size_t dataSize = sizeof(data) - 1;
  59
  60     ArrayBufferBuilder builder(2 * dataSize);
  61
  62     EXPECT_EQ(dataSize, builder.append(data, dataSize));
  63     EXPECT_EQ(dataSize, builder.byteLength());
  64     EXPECT_EQ(dataSize * 2, builder.capacity());
  65
  66     EXPECT_EQ(dataSize, builder.append(data, dataSize));
  67     EXPECT_EQ(dataSize * 2, builder.byteLength());
  68     EXPECT_EQ(dataSize * 2, builder.capacity());
  69
  70     EXPECT_EQ(dataSize, builder.append(data, dataSize));
  71     EXPECT_EQ(dataSize * 3, builder.byteLength());
  72     EXPECT_GE(builder.capacity(), dataSize * 3);
  73 }
  74
  75 TEST(ArrayBufferBuilder, AppendRepeatedly)
  76 {
  77     const char data[] = "HelloWorld";
  78     size_t dataSize = sizeof(data) - 1;
  79
  80     ArrayBufferBuilder builder(37); // Some number coprime with dataSize.
  81
  82     for (size_t i = 1; i < 1000U; ++i) {
  83         EXPECT_EQ(dataSize, builder.append(data, dataSize));
  84         EXPECT_EQ(dataSize * i, builder.byteLength());
  85         EXPECT_GE(builder.capacity(), dataSize * i);
  86     }
  87 }
  88
  89 TEST(ArrayBufferBuilder, DefaultConstructorAndAppendRepeatedly)
  90 {
  91     const char data[] = "HelloWorld";
  92     size_t dataSize = sizeof(data) - 1;
  93
  94     ArrayBufferBuilder builder;
  95
  96     for (size_t i = 1; i < 4000U; ++i) {
  97         EXPECT_EQ(dataSize, builder.append(data, dataSize));
  98         EXPECT_EQ(dataSize * i, builder.byteLength());
  99         EXPECT_GE(builder.capacity(), dataSize * i);
 100     }
 101 }
 102
 103 TEST(ArrayBufferBuilder, AppendFixedCapacity)
 104 {
 105     const char data[] = "HelloWorld";
 106     size_t dataSize = sizeof(data) - 1;
 107
 108     ArrayBufferBuilder builder(15);
 109     builder.setVariableCapacity(false);
 110
 111     EXPECT_EQ(dataSize, builder.append(data, dataSize));
 112     EXPECT_EQ(dataSize, builder.byteLength());
 113     EXPECT_EQ(15u, builder.capacity());
 114
 115     EXPECT_EQ(5u, builder.append(data, dataSize));
 116     EXPECT_EQ(15u, builder.byteLength());
 117     EXPECT_EQ(15u, builder.capacity());
 118
 119     EXPECT_EQ(0u, builder.append(data, dataSize));
 120     EXPECT_EQ(15u, builder.byteLength());
 121     EXPECT_EQ(15u, builder.capacity());
 122 }
 123
 124 TEST(ArrayBufferBuilder, ToArrayBuffer)
 125 {
 126     const char data1[] = "HelloWorld";
 127     size_t data1Size = sizeof(data1) - 1;
 128
 129     const char data2[] = "GoodbyeWorld";
 130     size_t data2Size = sizeof(data2) - 1;
 131
 132     ArrayBufferBuilder builder(1024);
 133     builder.append(data1, data1Size);
 134     builder.append(data2, data2Size);
 135
 136     const char expected[] = "HelloWorldGoodbyeWorld";
 137     size_t expectedSize = sizeof(expected) - 1;
 138
 139     RefPtr<ArrayBuffer> result = builder.toArrayBuffer();
 140     ASSERT_EQ(data1Size + data2Size, result->byteLength());
 141     ASSERT_EQ(expectedSize, result->byteLength());
 142     EXPECT_EQ(0, memcmp(expected, result->data(), expectedSize));
 143 }
 144
 145 TEST(ArrayBufferBuilder, ToArrayBufferSameAddressIfExactCapacity)
 146 {
 147     const char data[] = "HelloWorld";
 148     size_t dataSize = sizeof(data) - 1;
 149
 150     ArrayBufferBuilder builder(dataSize);
 151     builder.append(data, dataSize);
 152
 153     RefPtr<ArrayBuffer> result1 = builder.toArrayBuffer();
 154     RefPtr<ArrayBuffer> result2 = builder.toArrayBuffer();
 155     EXPECT_EQ(result1.get(), result2.get());
 156 }
 157
 158 TEST(ArrayBufferBuilder, ToString)
 159 {
 160     const char data1[] = "HelloWorld";
 161     size_t data1Size = sizeof(data1) - 1;
 162
 163     const char data2[] = "GoodbyeWorld";
 164     size_t data2Size = sizeof(data2) - 1;
 165
 166     ArrayBufferBuilder builder(1024);
 167     builder.append(data1, data1Size);
 168     builder.append(data2, data2Size);
 169
 170     const char expected[] = "HelloWorldGoodbyeWorld";
 171     size_t expectedSize = sizeof(expected) - 1;
 172
 173     String result = builder.toString();
 174     EXPECT_EQ(expectedSize, result.length());
 175     for (unsigned i = 0; i < result.length(); ++i)
 176         EXPECT_EQ(expected[i], result[i]);
 177 }
 178
 179 TEST(ArrayBufferBuilder, ShrinkToFitNoAppend)
 180 {
 181     ArrayBufferBuilder builder(1024);
 182     EXPECT_EQ(1024u, builder.capacity());
 183     builder.shrinkToFit();
 184     EXPECT_EQ(0u, builder.byteLength());
 185     EXPECT_EQ(0u, builder.capacity());
 186 }
 187
 188 TEST(ArrayBufferBuilder, ShrinkToFit)
 189 {
 190     const char data[] = "HelloWorld";
 191     size_t dataSize = sizeof(data) - 1;
 192
 193     ArrayBufferBuilder builder(32);
 194
 195     EXPECT_EQ(dataSize, builder.append(data, dataSize));
 196     EXPECT_EQ(dataSize, builder.byteLength());
 197     EXPECT_EQ(32u, builder.capacity());
 198
 199     builder.shrinkToFit();
 200     EXPECT_EQ(dataSize, builder.byteLength());
 201     EXPECT_EQ(dataSize, builder.capacity());
 202 }
 203
 204 TEST(ArrayBufferBuilder, ShrinkToFitFullyUsed)
 205 {
 206     const char data[] = "HelloWorld";
 207     size_t dataSize = sizeof(data) - 1;
 208
 209     ArrayBufferBuilder builder(dataSize);
 210     const void* internalAddress = builder.data();
 211
 212     EXPECT_EQ(dataSize, builder.append(data, dataSize));
 213     EXPECT_EQ(dataSize, builder.byteLength());
 214     EXPECT_EQ(dataSize, builder.capacity());
 215
 216     builder.shrinkToFit();
 217     // Reallocation should not happen.
 218     EXPECT_EQ(internalAddress, builder.data());
 219     EXPECT_EQ(dataSize, builder.byteLength());
 220     EXPECT_EQ(dataSize, builder.capacity());
 221 }
 222
 223 TEST(ArrayBufferBuilder, ShrinkToFitAfterGrowth)
 224 {
 225     const char data[] = "HelloWorld";
 226     size_t dataSize = sizeof(data) - 1;
 227
 228     ArrayBufferBuilder builder(5);
 229
 230     EXPECT_EQ(dataSize, builder.append(data, dataSize));
 231     EXPECT_GE(builder.capacity(), dataSize);
 232     builder.shrinkToFit();
 233     EXPECT_EQ(dataSize, builder.byteLength());
 234     EXPECT_EQ(dataSize, builder.capacity());
 235 }
 236
 237 } // namespace WTF