objectivec/Tests/GPBArrayTests.m

// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc.  All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#import <Foundation/Foundation.h>
#import <XCTest/XCTest.h>

#import "GPBArray.h"
#import "GPBArray_PackagePrivate.h"

#import "GPBTestUtilities.h"

// To let the testing macros work, add some extra methods to simplify things.
@interface GPBEnumArray (TestingTweak)
+ (instancetype)arrayWithValue:(int32_t)value;
+ (instancetype)arrayWithCapacity:(NSUInteger)count;
- (instancetype)initWithValues:(const int32_t [])values
                         count:(NSUInteger)count;
@end

static BOOL TestingEnum_IsValidValue(int32_t value) {
  switch (value) {
    case 71:
    case 72:
    case 73:
    case 74:
      return YES;
    default:
      return NO;
  }
}

static BOOL TestingEnum_IsValidValue2(int32_t value) {
  switch (value) {
    case 71:
    case 72:
    case 73:
      return YES;
    default:
      return NO;
  }
}

@implementation GPBEnumArray (TestingTweak)
+ (instancetype)arrayWithValue:(int32_t)value {
  return [[[self alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                         rawValues:&value
                                             count:1] autorelease];
}
+ (instancetype)arrayWithCapacity:(NSUInteger)count {
  return [[[self alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                          capacity:count] autorelease];
}
- (instancetype)initWithValues:(const int32_t [])values
                         count:(NSUInteger)count {
  return [self initWithValidationFunction:TestingEnum_IsValidValue
                                rawValues:values
                                    count:count];
}
@end

#pragma mark - PDDM Macros

//%PDDM-DEFINE ARRAY_TESTS(NAME, TYPE, VAL1, VAL2, VAL3, VAL4)
//%ARRAY_TESTS2(NAME, TYPE, VAL1, VAL2, VAL3, VAL4, )
//%PDDM-DEFINE ARRAY_TESTS2(NAME, TYPE, VAL1, VAL2, VAL3, VAL4, HELPER)
//%#pragma mark - NAME
//%
//%@interface GPB##NAME##ArrayTests : XCTestCase
//%@end
//%
//%@implementation GPB##NAME##ArrayTests
//%
//%- (void)testEmpty {
//%  GPB##NAME##Array *array = [[GPB##NAME##Array alloc] init];
//%  XCTAssertNotNil(array);
//%  XCTAssertEqual(array.count, 0U);
//%  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
//%  [array enumerateValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    #pragma unused(value, idx, stop)
//%    XCTFail(@"Shouldn't get here!");
//%  }];
//%  [array enumerateValuesWithOptions:NSEnumerationReverse
//%                         usingBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    #pragma unused(value, idx, stop)
//%    XCTFail(@"Shouldn't get here!");
//%  }];
//%  [array release];
//%}
//%
//%- (void)testOne {
//%  GPB##NAME##Array *array = [GPB##NAME##Array arrayWithValue:VAL1];
//%  XCTAssertNotNil(array);
//%  XCTAssertEqual(array.count, 1U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
//%  [array enumerateValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, 0U);
//%    XCTAssertEqual(value, VAL1);
//%    XCTAssertNotEqual(stop, NULL);
//%  }];
//%  [array enumerateValuesWithOptions:NSEnumerationReverse
//%                         usingBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, 0U);
//%    XCTAssertEqual(value, VAL1);
//%    XCTAssertNotEqual(stop, NULL);
//%  }];
//%}
//%
//%- (void)testBasics {
//%  static const TYPE kValues[] = { VAL1, VAL2, VAL3, VAL4 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%  XCTAssertEqual(array.count, 4U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertEqual([array valueAtIndex:1], VAL2);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%  XCTAssertEqual([array valueAtIndex:3], VAL4);
//%  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
//%  __block NSUInteger idx2 = 0;
//%  [array enumerateValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, idx2);
//%    XCTAssertEqual(value, kValues[idx]);
//%    XCTAssertNotEqual(stop, NULL);
//%    ++idx2;
//%  }];
//%  idx2 = 0;
//%  [array enumerateValuesWithOptions:NSEnumerationReverse
//%                         usingBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, (3 - idx2));
//%    XCTAssertEqual(value, kValues[idx]);
//%    XCTAssertNotEqual(stop, NULL);
//%    ++idx2;
//%  }];
//%  // Stopping the enumeration.
//%  idx2 = 0;
//%  [array enumerateValuesWithBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, idx2);
//%    XCTAssertEqual(value, kValues[idx]);
//%    XCTAssertNotEqual(stop, NULL);
//%    if (idx2 == 1) *stop = YES;
//%    XCTAssertNotEqual(idx, 2U);
//%    XCTAssertNotEqual(idx, 3U);
//%    ++idx2;
//%  }];
//%  idx2 = 0;
//%  [array enumerateValuesWithOptions:NSEnumerationReverse
//%                         usingBlock:^(TYPE value, NSUInteger idx, BOOL *stop) {
//%    XCTAssertEqual(idx, (3 - idx2));
//%    XCTAssertEqual(value, kValues[idx]);
//%    XCTAssertNotEqual(stop, NULL);
//%    if (idx2 == 1) *stop = YES;
//%    XCTAssertNotEqual(idx, 1U);
//%    XCTAssertNotEqual(idx, 0U);
//%    ++idx2;
//%  }];
//%  // Ensure description doesn't choke.
//%  XCTAssertTrue(array.description.length > 10);
//%  [array release];
//%}
//%
//%- (void)testEquality {
//%  const TYPE kValues1[] = { VAL1, VAL2, VAL3 };
//%  const TYPE kValues2[] = { VAL1, VAL4, VAL3 };
//%  const TYPE kValues3[] = { VAL1, VAL2, VAL3, VAL4 };
//%  GPB##NAME##Array *array1 =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues1
//%            NAME$S                     count:GPBARRAYSIZE(kValues1)];
//%  XCTAssertNotNil(array1);
//%  GPB##NAME##Array *array1prime =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues1
//%            NAME$S                     count:GPBARRAYSIZE(kValues1)];
//%  XCTAssertNotNil(array1prime);
//%  GPB##NAME##Array *array2 =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues2
//%            NAME$S                     count:GPBARRAYSIZE(kValues2)];
//%  XCTAssertNotNil(array2);
//%  GPB##NAME##Array *array3 =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues3
//%            NAME$S                     count:GPBARRAYSIZE(kValues3)];
//%  XCTAssertNotNil(array3);
//%
//%  // Identity
//%  XCTAssertTrue([array1 isEqual:array1]);
//%  // Wrong type doesn't blow up.
//%  XCTAssertFalse([array1 isEqual:@"bogus"]);
//%  // 1/1Prime should be different objects, but equal.
//%  XCTAssertNotEqual(array1, array1prime);
//%  XCTAssertEqualObjects(array1, array1prime);
//%  // Equal, so they must have same hash.
//%  XCTAssertEqual([array1 hash], [array1prime hash]);
//%
//%  // 1/2/3 shouldn't be equal.
//%  XCTAssertNotEqualObjects(array1, array2);
//%  XCTAssertNotEqualObjects(array1, array3);
//%  XCTAssertNotEqualObjects(array2, array3);
//%
//%  [array1 release];
//%  [array1prime release];
//%  [array2 release];
//%  [array3 release];
//%}
//%
//%- (void)testCopy {
//%  const TYPE kValues[] = { VAL1, VAL2, VAL3, VAL4 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%
//%  GPB##NAME##Array *array2 = [array copy];
//%  XCTAssertNotNil(array2);
//%
//%  // Should be new object but equal.
//%  XCTAssertNotEqual(array, array2);
//%  XCTAssertEqualObjects(array, array2);
//%  [array2 release];
//%  [array release];
//%}
//%
//%- (void)testArrayFromArray {
//%  const TYPE kValues[] = { VAL1, VAL2, VAL3, VAL4 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%
//%  GPB##NAME##Array *array2 = [GPB##NAME##Array arrayWithValueArray:array];
//%  XCTAssertNotNil(array2);
//%
//%  // Should be new pointer, but equal objects.
//%  XCTAssertNotEqual(array, array2);
//%  XCTAssertEqualObjects(array, array2);
//%  [array release];
//%}
//%
//%- (void)testAdds {
//%  GPB##NAME##Array *array = [GPB##NAME##Array array];
//%  XCTAssertNotNil(array);
//%
//%  XCTAssertEqual(array.count, 0U);
//%  [array addValue:VAL1];
//%  XCTAssertEqual(array.count, 1U);
//%
//%  const TYPE kValues1[] = { VAL2, VAL3 };
//%  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
//%  XCTAssertEqual(array.count, 3U);
//%
//%  const TYPE kValues2[] = { VAL4, VAL1 };
//%  GPB##NAME##Array *array2 =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues2
//%            NAME$S                     count:GPBARRAYSIZE(kValues2)];
//%  XCTAssertNotNil(array2);
//%  [array add##HELPER##ValuesFromArray:array2];
//%  XCTAssertEqual(array.count, 5U);
//%
//%  // Zero/nil inputs do nothing.
//%  [array addValues:kValues1 count:0];
//%  XCTAssertEqual(array.count, 5U);
//%  [array addValues:NULL count:5];
//%  XCTAssertEqual(array.count, 5U);
//%
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertEqual([array valueAtIndex:1], VAL2);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%  XCTAssertEqual([array valueAtIndex:3], VAL4);
//%  XCTAssertEqual([array valueAtIndex:4], VAL1);
//%  [array2 release];
//%}
//%
//%- (void)testInsert {
//%  const TYPE kValues[] = { VAL1, VAL2, VAL3 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%  XCTAssertEqual(array.count, 3U);
//%
//%  // First
//%  [array insertValue:VAL4 atIndex:0];
//%  XCTAssertEqual(array.count, 4U);
//%
//%  // Middle
//%  [array insertValue:VAL4 atIndex:2];
//%  XCTAssertEqual(array.count, 5U);
//%
//%  // End
//%  [array insertValue:VAL4 atIndex:5];
//%  XCTAssertEqual(array.count, 6U);
//%
//%  // Too far.
//%  XCTAssertThrowsSpecificNamed([array insertValue:VAL4 atIndex:7],
//%                               NSException, NSRangeException);
//%
//%  XCTAssertEqual([array valueAtIndex:0], VAL4);
//%  XCTAssertEqual([array valueAtIndex:1], VAL1);
//%  XCTAssertEqual([array valueAtIndex:2], VAL4);
//%  XCTAssertEqual([array valueAtIndex:3], VAL2);
//%  XCTAssertEqual([array valueAtIndex:4], VAL3);
//%  XCTAssertEqual([array valueAtIndex:5], VAL4);
//%  [array release];
//%}
//%
//%- (void)testRemove {
//%  const TYPE kValues[] = { VAL4, VAL1, VAL2, VAL4, VAL3, VAL4 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%  XCTAssertEqual(array.count, 6U);
//%
//%  // First
//%  [array removeValueAtIndex:0];
//%  XCTAssertEqual(array.count, 5U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%
//%  // Middle
//%  [array removeValueAtIndex:2];
//%  XCTAssertEqual(array.count, 4U);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%
//%  // End
//%  [array removeValueAtIndex:3];
//%  XCTAssertEqual(array.count, 3U);
//%
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertEqual([array valueAtIndex:1], VAL2);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%
//%  // Too far.
//%  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
//%                               NSException, NSRangeException);
//%
//%  [array removeAll];
//%  XCTAssertEqual(array.count, 0U);
//%  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
//%                               NSException, NSRangeException);
//%  [array release];
//%}
//%
//%- (void)testInplaceMutation {
//%  const TYPE kValues[] = { VAL1, VAL1, VAL3, VAL3 };
//%  GPB##NAME##Array *array =
//%      [[GPB##NAME##Array alloc] initWithValues:kValues
//%            NAME$S                     count:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%
//%  [array replaceValueAtIndex:1 withValue:VAL2];
//%  [array replaceValueAtIndex:3 withValue:VAL4];
//%  XCTAssertEqual(array.count, 4U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertEqual([array valueAtIndex:1], VAL2);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%  XCTAssertEqual([array valueAtIndex:3], VAL4);
//%
//%  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:VAL4],
//%                               NSException, NSRangeException);
//%
//%  [array exchangeValueAtIndex:1 withValueAtIndex:3];
//%  XCTAssertEqual(array.count, 4U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL1);
//%  XCTAssertEqual([array valueAtIndex:1], VAL4);
//%  XCTAssertEqual([array valueAtIndex:2], VAL3);
//%  XCTAssertEqual([array valueAtIndex:3], VAL2);
//%
//%  [array exchangeValueAtIndex:2 withValueAtIndex:0];
//%  XCTAssertEqual(array.count, 4U);
//%  XCTAssertEqual([array valueAtIndex:0], VAL3);
//%  XCTAssertEqual([array valueAtIndex:1], VAL4);
//%  XCTAssertEqual([array valueAtIndex:2], VAL1);
//%  XCTAssertEqual([array valueAtIndex:3], VAL2);
//%
//%  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
//%                               NSException, NSRangeException);
//%  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
//%                               NSException, NSRangeException);
//%  [array release];
//%}
//%
//%- (void)testInternalResizing {
//%  const TYPE kValues[] = { VAL1, VAL2, VAL3, VAL4 };
//%  GPB##NAME##Array *array =
//%      [GPB##NAME##Array arrayWithCapacity:GPBARRAYSIZE(kValues)];
//%  XCTAssertNotNil(array);
//%  [array addValues:kValues count:GPBARRAYSIZE(kValues)];
//%
//%  // Add/remove to trigger the intneral buffer to grow/shrink.
//%  for (int i = 0; i < 100; ++i) {
//%    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
//%  }
//%  XCTAssertEqual(array.count, 404U);
//%  for (int i = 0; i < 100; ++i) {
//%    [array removeValueAtIndex:(i * 2)];
//%  }
//%  XCTAssertEqual(array.count, 304U);
//%  for (int i = 0; i < 100; ++i) {
//%    [array insertValue:VAL4 atIndex:(i * 3)];
//%  }
//%  XCTAssertEqual(array.count, 404U);
//%  [array removeAll];
//%  XCTAssertEqual(array.count, 0U);
//%}
//%
//%@end
//%
//%PDDM-EXPAND ARRAY_TESTS(Int32, int32_t, 1, 2, 3, 4)
// This block of code is generated, do not edit it directly.

#pragma mark - Int32

@interface GPBInt32ArrayTests : XCTestCase
@end

@implementation GPBInt32ArrayTests

- (void)testEmpty {
  GPBInt32Array *array = [[GPBInt32Array alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBInt32Array *array = [GPBInt32Array arrayWithValue:1];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 1);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 1);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const int32_t kValues[] = { 1, 2, 3, 4 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertEqual([array valueAtIndex:1], 2);
  XCTAssertEqual([array valueAtIndex:2], 3);
  XCTAssertEqual([array valueAtIndex:3], 4);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const int32_t kValues1[] = { 1, 2, 3 };
  const int32_t kValues2[] = { 1, 4, 3 };
  const int32_t kValues3[] = { 1, 2, 3, 4 };
  GPBInt32Array *array1 =
      [[GPBInt32Array alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBInt32Array *array1prime =
      [[GPBInt32Array alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBInt32Array *array2 =
      [[GPBInt32Array alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBInt32Array *array3 =
      [[GPBInt32Array alloc] initWithValues:kValues3
                                      count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const int32_t kValues[] = { 1, 2, 3, 4 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBInt32Array *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const int32_t kValues[] = { 1, 2, 3, 4 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBInt32Array *array2 = [GPBInt32Array arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBInt32Array *array = [GPBInt32Array array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:1];
  XCTAssertEqual(array.count, 1U);

  const int32_t kValues1[] = { 2, 3 };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const int32_t kValues2[] = { 4, 1 };
  GPBInt32Array *array2 =
      [[GPBInt32Array alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertEqual([array valueAtIndex:1], 2);
  XCTAssertEqual([array valueAtIndex:2], 3);
  XCTAssertEqual([array valueAtIndex:3], 4);
  XCTAssertEqual([array valueAtIndex:4], 1);
  [array2 release];
}

- (void)testInsert {
  const int32_t kValues[] = { 1, 2, 3 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:4 atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:4 atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:4 atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:4 atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 4);
  XCTAssertEqual([array valueAtIndex:1], 1);
  XCTAssertEqual([array valueAtIndex:2], 4);
  XCTAssertEqual([array valueAtIndex:3], 2);
  XCTAssertEqual([array valueAtIndex:4], 3);
  XCTAssertEqual([array valueAtIndex:5], 4);
  [array release];
}

- (void)testRemove {
  const int32_t kValues[] = { 4, 1, 2, 4, 3, 4 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 1);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 3);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertEqual([array valueAtIndex:1], 2);
  XCTAssertEqual([array valueAtIndex:2], 3);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const int32_t kValues[] = { 1, 1, 3, 3 };
  GPBInt32Array *array =
      [[GPBInt32Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:2];
  [array replaceValueAtIndex:3 withValue:4];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertEqual([array valueAtIndex:1], 2);
  XCTAssertEqual([array valueAtIndex:2], 3);
  XCTAssertEqual([array valueAtIndex:3], 4);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:4],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 1);
  XCTAssertEqual([array valueAtIndex:1], 4);
  XCTAssertEqual([array valueAtIndex:2], 3);
  XCTAssertEqual([array valueAtIndex:3], 2);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 3);
  XCTAssertEqual([array valueAtIndex:1], 4);
  XCTAssertEqual([array valueAtIndex:2], 1);
  XCTAssertEqual([array valueAtIndex:3], 2);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const int32_t kValues[] = { 1, 2, 3, 4 };
  GPBInt32Array *array =
      [GPBInt32Array arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:4 atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(UInt32, uint32_t, 11U, 12U, 13U, 14U)
// This block of code is generated, do not edit it directly.

#pragma mark - UInt32

@interface GPBUInt32ArrayTests : XCTestCase
@end

@implementation GPBUInt32ArrayTests

- (void)testEmpty {
  GPBUInt32Array *array = [[GPBUInt32Array alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBUInt32Array *array = [GPBUInt32Array arrayWithValue:11U];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 11U);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 11U);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const uint32_t kValues[] = { 11U, 12U, 13U, 14U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertEqual([array valueAtIndex:1], 12U);
  XCTAssertEqual([array valueAtIndex:2], 13U);
  XCTAssertEqual([array valueAtIndex:3], 14U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const uint32_t kValues1[] = { 11U, 12U, 13U };
  const uint32_t kValues2[] = { 11U, 14U, 13U };
  const uint32_t kValues3[] = { 11U, 12U, 13U, 14U };
  GPBUInt32Array *array1 =
      [[GPBUInt32Array alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBUInt32Array *array1prime =
      [[GPBUInt32Array alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBUInt32Array *array2 =
      [[GPBUInt32Array alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBUInt32Array *array3 =
      [[GPBUInt32Array alloc] initWithValues:kValues3
                                       count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const uint32_t kValues[] = { 11U, 12U, 13U, 14U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBUInt32Array *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const uint32_t kValues[] = { 11U, 12U, 13U, 14U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBUInt32Array *array2 = [GPBUInt32Array arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBUInt32Array *array = [GPBUInt32Array array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:11U];
  XCTAssertEqual(array.count, 1U);

  const uint32_t kValues1[] = { 12U, 13U };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const uint32_t kValues2[] = { 14U, 11U };
  GPBUInt32Array *array2 =
      [[GPBUInt32Array alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertEqual([array valueAtIndex:1], 12U);
  XCTAssertEqual([array valueAtIndex:2], 13U);
  XCTAssertEqual([array valueAtIndex:3], 14U);
  XCTAssertEqual([array valueAtIndex:4], 11U);
  [array2 release];
}

- (void)testInsert {
  const uint32_t kValues[] = { 11U, 12U, 13U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:14U atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:14U atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:14U atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:14U atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 14U);
  XCTAssertEqual([array valueAtIndex:1], 11U);
  XCTAssertEqual([array valueAtIndex:2], 14U);
  XCTAssertEqual([array valueAtIndex:3], 12U);
  XCTAssertEqual([array valueAtIndex:4], 13U);
  XCTAssertEqual([array valueAtIndex:5], 14U);
  [array release];
}

- (void)testRemove {
  const uint32_t kValues[] = { 14U, 11U, 12U, 14U, 13U, 14U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 11U);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 13U);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertEqual([array valueAtIndex:1], 12U);
  XCTAssertEqual([array valueAtIndex:2], 13U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const uint32_t kValues[] = { 11U, 11U, 13U, 13U };
  GPBUInt32Array *array =
      [[GPBUInt32Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:12U];
  [array replaceValueAtIndex:3 withValue:14U];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertEqual([array valueAtIndex:1], 12U);
  XCTAssertEqual([array valueAtIndex:2], 13U);
  XCTAssertEqual([array valueAtIndex:3], 14U);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:14U],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 11U);
  XCTAssertEqual([array valueAtIndex:1], 14U);
  XCTAssertEqual([array valueAtIndex:2], 13U);
  XCTAssertEqual([array valueAtIndex:3], 12U);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 13U);
  XCTAssertEqual([array valueAtIndex:1], 14U);
  XCTAssertEqual([array valueAtIndex:2], 11U);
  XCTAssertEqual([array valueAtIndex:3], 12U);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const uint32_t kValues[] = { 11U, 12U, 13U, 14U };
  GPBUInt32Array *array =
      [GPBUInt32Array arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:14U atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(Int64, int64_t, 31LL, 32LL, 33LL, 34LL)
// This block of code is generated, do not edit it directly.

#pragma mark - Int64

@interface GPBInt64ArrayTests : XCTestCase
@end

@implementation GPBInt64ArrayTests

- (void)testEmpty {
  GPBInt64Array *array = [[GPBInt64Array alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBInt64Array *array = [GPBInt64Array arrayWithValue:31LL];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 31LL);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 31LL);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const int64_t kValues[] = { 31LL, 32LL, 33LL, 34LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertEqual([array valueAtIndex:1], 32LL);
  XCTAssertEqual([array valueAtIndex:2], 33LL);
  XCTAssertEqual([array valueAtIndex:3], 34LL);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const int64_t kValues1[] = { 31LL, 32LL, 33LL };
  const int64_t kValues2[] = { 31LL, 34LL, 33LL };
  const int64_t kValues3[] = { 31LL, 32LL, 33LL, 34LL };
  GPBInt64Array *array1 =
      [[GPBInt64Array alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBInt64Array *array1prime =
      [[GPBInt64Array alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBInt64Array *array2 =
      [[GPBInt64Array alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBInt64Array *array3 =
      [[GPBInt64Array alloc] initWithValues:kValues3
                                      count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const int64_t kValues[] = { 31LL, 32LL, 33LL, 34LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBInt64Array *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const int64_t kValues[] = { 31LL, 32LL, 33LL, 34LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBInt64Array *array2 = [GPBInt64Array arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBInt64Array *array = [GPBInt64Array array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:31LL];
  XCTAssertEqual(array.count, 1U);

  const int64_t kValues1[] = { 32LL, 33LL };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const int64_t kValues2[] = { 34LL, 31LL };
  GPBInt64Array *array2 =
      [[GPBInt64Array alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertEqual([array valueAtIndex:1], 32LL);
  XCTAssertEqual([array valueAtIndex:2], 33LL);
  XCTAssertEqual([array valueAtIndex:3], 34LL);
  XCTAssertEqual([array valueAtIndex:4], 31LL);
  [array2 release];
}

- (void)testInsert {
  const int64_t kValues[] = { 31LL, 32LL, 33LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:34LL atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:34LL atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:34LL atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:34LL atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 34LL);
  XCTAssertEqual([array valueAtIndex:1], 31LL);
  XCTAssertEqual([array valueAtIndex:2], 34LL);
  XCTAssertEqual([array valueAtIndex:3], 32LL);
  XCTAssertEqual([array valueAtIndex:4], 33LL);
  XCTAssertEqual([array valueAtIndex:5], 34LL);
  [array release];
}

- (void)testRemove {
  const int64_t kValues[] = { 34LL, 31LL, 32LL, 34LL, 33LL, 34LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 31LL);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 33LL);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertEqual([array valueAtIndex:1], 32LL);
  XCTAssertEqual([array valueAtIndex:2], 33LL);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const int64_t kValues[] = { 31LL, 31LL, 33LL, 33LL };
  GPBInt64Array *array =
      [[GPBInt64Array alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:32LL];
  [array replaceValueAtIndex:3 withValue:34LL];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertEqual([array valueAtIndex:1], 32LL);
  XCTAssertEqual([array valueAtIndex:2], 33LL);
  XCTAssertEqual([array valueAtIndex:3], 34LL);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:34LL],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 31LL);
  XCTAssertEqual([array valueAtIndex:1], 34LL);
  XCTAssertEqual([array valueAtIndex:2], 33LL);
  XCTAssertEqual([array valueAtIndex:3], 32LL);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 33LL);
  XCTAssertEqual([array valueAtIndex:1], 34LL);
  XCTAssertEqual([array valueAtIndex:2], 31LL);
  XCTAssertEqual([array valueAtIndex:3], 32LL);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const int64_t kValues[] = { 31LL, 32LL, 33LL, 34LL };
  GPBInt64Array *array =
      [GPBInt64Array arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:34LL atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(UInt64, uint64_t, 41ULL, 42ULL, 43ULL, 44ULL)
// This block of code is generated, do not edit it directly.

#pragma mark - UInt64

@interface GPBUInt64ArrayTests : XCTestCase
@end

@implementation GPBUInt64ArrayTests

- (void)testEmpty {
  GPBUInt64Array *array = [[GPBUInt64Array alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBUInt64Array *array = [GPBUInt64Array arrayWithValue:41ULL];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 41ULL);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 41ULL);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const uint64_t kValues[] = { 41ULL, 42ULL, 43ULL, 44ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertEqual([array valueAtIndex:1], 42ULL);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);
  XCTAssertEqual([array valueAtIndex:3], 44ULL);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(uint64_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const uint64_t kValues1[] = { 41ULL, 42ULL, 43ULL };
  const uint64_t kValues2[] = { 41ULL, 44ULL, 43ULL };
  const uint64_t kValues3[] = { 41ULL, 42ULL, 43ULL, 44ULL };
  GPBUInt64Array *array1 =
      [[GPBUInt64Array alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBUInt64Array *array1prime =
      [[GPBUInt64Array alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBUInt64Array *array2 =
      [[GPBUInt64Array alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBUInt64Array *array3 =
      [[GPBUInt64Array alloc] initWithValues:kValues3
                                       count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const uint64_t kValues[] = { 41ULL, 42ULL, 43ULL, 44ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBUInt64Array *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const uint64_t kValues[] = { 41ULL, 42ULL, 43ULL, 44ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBUInt64Array *array2 = [GPBUInt64Array arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBUInt64Array *array = [GPBUInt64Array array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:41ULL];
  XCTAssertEqual(array.count, 1U);

  const uint64_t kValues1[] = { 42ULL, 43ULL };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const uint64_t kValues2[] = { 44ULL, 41ULL };
  GPBUInt64Array *array2 =
      [[GPBUInt64Array alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertEqual([array valueAtIndex:1], 42ULL);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);
  XCTAssertEqual([array valueAtIndex:3], 44ULL);
  XCTAssertEqual([array valueAtIndex:4], 41ULL);
  [array2 release];
}

- (void)testInsert {
  const uint64_t kValues[] = { 41ULL, 42ULL, 43ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:44ULL atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:44ULL atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:44ULL atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:44ULL atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 44ULL);
  XCTAssertEqual([array valueAtIndex:1], 41ULL);
  XCTAssertEqual([array valueAtIndex:2], 44ULL);
  XCTAssertEqual([array valueAtIndex:3], 42ULL);
  XCTAssertEqual([array valueAtIndex:4], 43ULL);
  XCTAssertEqual([array valueAtIndex:5], 44ULL);
  [array release];
}

- (void)testRemove {
  const uint64_t kValues[] = { 44ULL, 41ULL, 42ULL, 44ULL, 43ULL, 44ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 41ULL);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertEqual([array valueAtIndex:1], 42ULL);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const uint64_t kValues[] = { 41ULL, 41ULL, 43ULL, 43ULL };
  GPBUInt64Array *array =
      [[GPBUInt64Array alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:42ULL];
  [array replaceValueAtIndex:3 withValue:44ULL];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertEqual([array valueAtIndex:1], 42ULL);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);
  XCTAssertEqual([array valueAtIndex:3], 44ULL);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:44ULL],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 41ULL);
  XCTAssertEqual([array valueAtIndex:1], 44ULL);
  XCTAssertEqual([array valueAtIndex:2], 43ULL);
  XCTAssertEqual([array valueAtIndex:3], 42ULL);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 43ULL);
  XCTAssertEqual([array valueAtIndex:1], 44ULL);
  XCTAssertEqual([array valueAtIndex:2], 41ULL);
  XCTAssertEqual([array valueAtIndex:3], 42ULL);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const uint64_t kValues[] = { 41ULL, 42ULL, 43ULL, 44ULL };
  GPBUInt64Array *array =
      [GPBUInt64Array arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:44ULL atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(Float, float, 51.f, 52.f, 53.f, 54.f)
// This block of code is generated, do not edit it directly.

#pragma mark - Float

@interface GPBFloatArrayTests : XCTestCase
@end

@implementation GPBFloatArrayTests

- (void)testEmpty {
  GPBFloatArray *array = [[GPBFloatArray alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(float value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBFloatArray *array = [GPBFloatArray arrayWithValue:51.f];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 51.f);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 51.f);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const float kValues[] = { 51.f, 52.f, 53.f, 54.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertEqual([array valueAtIndex:1], 52.f);
  XCTAssertEqual([array valueAtIndex:2], 53.f);
  XCTAssertEqual([array valueAtIndex:3], 54.f);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(float value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const float kValues1[] = { 51.f, 52.f, 53.f };
  const float kValues2[] = { 51.f, 54.f, 53.f };
  const float kValues3[] = { 51.f, 52.f, 53.f, 54.f };
  GPBFloatArray *array1 =
      [[GPBFloatArray alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBFloatArray *array1prime =
      [[GPBFloatArray alloc] initWithValues:kValues1
                                      count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBFloatArray *array2 =
      [[GPBFloatArray alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBFloatArray *array3 =
      [[GPBFloatArray alloc] initWithValues:kValues3
                                      count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const float kValues[] = { 51.f, 52.f, 53.f, 54.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBFloatArray *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const float kValues[] = { 51.f, 52.f, 53.f, 54.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBFloatArray *array2 = [GPBFloatArray arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBFloatArray *array = [GPBFloatArray array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:51.f];
  XCTAssertEqual(array.count, 1U);

  const float kValues1[] = { 52.f, 53.f };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const float kValues2[] = { 54.f, 51.f };
  GPBFloatArray *array2 =
      [[GPBFloatArray alloc] initWithValues:kValues2
                                      count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertEqual([array valueAtIndex:1], 52.f);
  XCTAssertEqual([array valueAtIndex:2], 53.f);
  XCTAssertEqual([array valueAtIndex:3], 54.f);
  XCTAssertEqual([array valueAtIndex:4], 51.f);
  [array2 release];
}

- (void)testInsert {
  const float kValues[] = { 51.f, 52.f, 53.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:54.f atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:54.f atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:54.f atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:54.f atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 54.f);
  XCTAssertEqual([array valueAtIndex:1], 51.f);
  XCTAssertEqual([array valueAtIndex:2], 54.f);
  XCTAssertEqual([array valueAtIndex:3], 52.f);
  XCTAssertEqual([array valueAtIndex:4], 53.f);
  XCTAssertEqual([array valueAtIndex:5], 54.f);
  [array release];
}

- (void)testRemove {
  const float kValues[] = { 54.f, 51.f, 52.f, 54.f, 53.f, 54.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 51.f);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 53.f);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertEqual([array valueAtIndex:1], 52.f);
  XCTAssertEqual([array valueAtIndex:2], 53.f);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const float kValues[] = { 51.f, 51.f, 53.f, 53.f };
  GPBFloatArray *array =
      [[GPBFloatArray alloc] initWithValues:kValues
                                      count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:52.f];
  [array replaceValueAtIndex:3 withValue:54.f];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertEqual([array valueAtIndex:1], 52.f);
  XCTAssertEqual([array valueAtIndex:2], 53.f);
  XCTAssertEqual([array valueAtIndex:3], 54.f);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:54.f],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 51.f);
  XCTAssertEqual([array valueAtIndex:1], 54.f);
  XCTAssertEqual([array valueAtIndex:2], 53.f);
  XCTAssertEqual([array valueAtIndex:3], 52.f);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 53.f);
  XCTAssertEqual([array valueAtIndex:1], 54.f);
  XCTAssertEqual([array valueAtIndex:2], 51.f);
  XCTAssertEqual([array valueAtIndex:3], 52.f);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const float kValues[] = { 51.f, 52.f, 53.f, 54.f };
  GPBFloatArray *array =
      [GPBFloatArray arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:54.f atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(Double, double, 61., 62., 63., 64.)
// This block of code is generated, do not edit it directly.

#pragma mark - Double

@interface GPBDoubleArrayTests : XCTestCase
@end

@implementation GPBDoubleArrayTests

- (void)testEmpty {
  GPBDoubleArray *array = [[GPBDoubleArray alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(double value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBDoubleArray *array = [GPBDoubleArray arrayWithValue:61.];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 61.);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 61.);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const double kValues[] = { 61., 62., 63., 64. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertEqual([array valueAtIndex:1], 62.);
  XCTAssertEqual([array valueAtIndex:2], 63.);
  XCTAssertEqual([array valueAtIndex:3], 64.);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(double value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const double kValues1[] = { 61., 62., 63. };
  const double kValues2[] = { 61., 64., 63. };
  const double kValues3[] = { 61., 62., 63., 64. };
  GPBDoubleArray *array1 =
      [[GPBDoubleArray alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBDoubleArray *array1prime =
      [[GPBDoubleArray alloc] initWithValues:kValues1
                                       count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBDoubleArray *array2 =
      [[GPBDoubleArray alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBDoubleArray *array3 =
      [[GPBDoubleArray alloc] initWithValues:kValues3
                                       count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const double kValues[] = { 61., 62., 63., 64. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBDoubleArray *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const double kValues[] = { 61., 62., 63., 64. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBDoubleArray *array2 = [GPBDoubleArray arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBDoubleArray *array = [GPBDoubleArray array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:61.];
  XCTAssertEqual(array.count, 1U);

  const double kValues1[] = { 62., 63. };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const double kValues2[] = { 64., 61. };
  GPBDoubleArray *array2 =
      [[GPBDoubleArray alloc] initWithValues:kValues2
                                       count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertEqual([array valueAtIndex:1], 62.);
  XCTAssertEqual([array valueAtIndex:2], 63.);
  XCTAssertEqual([array valueAtIndex:3], 64.);
  XCTAssertEqual([array valueAtIndex:4], 61.);
  [array2 release];
}

- (void)testInsert {
  const double kValues[] = { 61., 62., 63. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:64. atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:64. atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:64. atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:64. atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 64.);
  XCTAssertEqual([array valueAtIndex:1], 61.);
  XCTAssertEqual([array valueAtIndex:2], 64.);
  XCTAssertEqual([array valueAtIndex:3], 62.);
  XCTAssertEqual([array valueAtIndex:4], 63.);
  XCTAssertEqual([array valueAtIndex:5], 64.);
  [array release];
}

- (void)testRemove {
  const double kValues[] = { 64., 61., 62., 64., 63., 64. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 61.);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 63.);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertEqual([array valueAtIndex:1], 62.);
  XCTAssertEqual([array valueAtIndex:2], 63.);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const double kValues[] = { 61., 61., 63., 63. };
  GPBDoubleArray *array =
      [[GPBDoubleArray alloc] initWithValues:kValues
                                       count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:62.];
  [array replaceValueAtIndex:3 withValue:64.];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertEqual([array valueAtIndex:1], 62.);
  XCTAssertEqual([array valueAtIndex:2], 63.);
  XCTAssertEqual([array valueAtIndex:3], 64.);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:64.],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 61.);
  XCTAssertEqual([array valueAtIndex:1], 64.);
  XCTAssertEqual([array valueAtIndex:2], 63.);
  XCTAssertEqual([array valueAtIndex:3], 62.);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 63.);
  XCTAssertEqual([array valueAtIndex:1], 64.);
  XCTAssertEqual([array valueAtIndex:2], 61.);
  XCTAssertEqual([array valueAtIndex:3], 62.);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const double kValues[] = { 61., 62., 63., 64. };
  GPBDoubleArray *array =
      [GPBDoubleArray arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:64. atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS(Bool, BOOL, TRUE, TRUE, FALSE, FALSE)
// This block of code is generated, do not edit it directly.

#pragma mark - Bool

@interface GPBBoolArrayTests : XCTestCase
@end

@implementation GPBBoolArrayTests

- (void)testEmpty {
  GPBBoolArray *array = [[GPBBoolArray alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBBoolArray *array = [GPBBoolArray arrayWithValue:TRUE];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, TRUE);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, TRUE);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const BOOL kValues[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertEqual([array valueAtIndex:1], TRUE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);
  XCTAssertEqual([array valueAtIndex:3], FALSE);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(BOOL value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const BOOL kValues1[] = { TRUE, TRUE, FALSE };
  const BOOL kValues2[] = { TRUE, FALSE, FALSE };
  const BOOL kValues3[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array1 =
      [[GPBBoolArray alloc] initWithValues:kValues1
                                     count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBBoolArray *array1prime =
      [[GPBBoolArray alloc] initWithValues:kValues1
                                     count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBBoolArray *array2 =
      [[GPBBoolArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBBoolArray *array3 =
      [[GPBBoolArray alloc] initWithValues:kValues3
                                     count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const BOOL kValues[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBBoolArray *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const BOOL kValues[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBBoolArray *array2 = [GPBBoolArray arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBBoolArray *array = [GPBBoolArray array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:TRUE];
  XCTAssertEqual(array.count, 1U);

  const BOOL kValues1[] = { TRUE, FALSE };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const BOOL kValues2[] = { FALSE, TRUE };
  GPBBoolArray *array2 =
      [[GPBBoolArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertEqual([array valueAtIndex:1], TRUE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);
  XCTAssertEqual([array valueAtIndex:3], FALSE);
  XCTAssertEqual([array valueAtIndex:4], TRUE);
  [array2 release];
}

- (void)testInsert {
  const BOOL kValues[] = { TRUE, TRUE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:FALSE atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:FALSE atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:FALSE atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:FALSE atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], FALSE);
  XCTAssertEqual([array valueAtIndex:1], TRUE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);
  XCTAssertEqual([array valueAtIndex:3], TRUE);
  XCTAssertEqual([array valueAtIndex:4], FALSE);
  XCTAssertEqual([array valueAtIndex:5], FALSE);
  [array release];
}

- (void)testRemove {
  const BOOL kValues[] = { FALSE, TRUE, TRUE, FALSE, FALSE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], TRUE);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], FALSE);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertEqual([array valueAtIndex:1], TRUE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const BOOL kValues[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array =
      [[GPBBoolArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:TRUE];
  [array replaceValueAtIndex:3 withValue:FALSE];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertEqual([array valueAtIndex:1], TRUE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);
  XCTAssertEqual([array valueAtIndex:3], FALSE);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:FALSE],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], TRUE);
  XCTAssertEqual([array valueAtIndex:1], FALSE);
  XCTAssertEqual([array valueAtIndex:2], FALSE);
  XCTAssertEqual([array valueAtIndex:3], TRUE);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], FALSE);
  XCTAssertEqual([array valueAtIndex:1], FALSE);
  XCTAssertEqual([array valueAtIndex:2], TRUE);
  XCTAssertEqual([array valueAtIndex:3], TRUE);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const BOOL kValues[] = { TRUE, TRUE, FALSE, FALSE };
  GPBBoolArray *array =
      [GPBBoolArray arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:FALSE atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND ARRAY_TESTS2(Enum, int32_t, 71, 72, 73, 74, Raw)
// This block of code is generated, do not edit it directly.

#pragma mark - Enum

@interface GPBEnumArrayTests : XCTestCase
@end

@implementation GPBEnumArrayTests

- (void)testEmpty {
  GPBEnumArray *array = [[GPBEnumArray alloc] init];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:0], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    #pragma unused(value, idx, stop)
    XCTFail(@"Shouldn't get here!");
  }];
  [array release];
}

- (void)testOne {
  GPBEnumArray *array = [GPBEnumArray arrayWithValue:71];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 1U);
  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:1], NSException, NSRangeException);
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 71);
    XCTAssertNotEqual(stop, NULL);
  }];
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, 0U);
    XCTAssertEqual(value, 71);
    XCTAssertNotEqual(stop, NULL);
  }];
}

- (void)testBasics {
  static const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 72);
  XCTAssertEqual([array valueAtIndex:2], 73);
  XCTAssertEqual([array valueAtIndex:3], 74);
  XCTAssertThrowsSpecificNamed([array valueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  // Ensure description doesn't choke.
  XCTAssertTrue(array.description.length > 10);
  [array release];
}

- (void)testEquality {
  const int32_t kValues1[] = { 71, 72, 73 };
  const int32_t kValues2[] = { 71, 74, 73 };
  const int32_t kValues3[] = { 71, 72, 73, 74 };
  GPBEnumArray *array1 =
      [[GPBEnumArray alloc] initWithValues:kValues1
                                     count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBEnumArray *array1prime =
      [[GPBEnumArray alloc] initWithValues:kValues1
                                     count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBEnumArray *array2 =
      [[GPBEnumArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBEnumArray *array3 =
      [[GPBEnumArray alloc] initWithValues:kValues3
                                     count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // Identity
  XCTAssertTrue([array1 isEqual:array1]);
  // Wrong type doesn't blow up.
  XCTAssertFalse([array1 isEqual:@"bogus"]);
  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBEnumArray *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBEnumArray *array2 = [GPBEnumArray arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  [array release];
}

- (void)testAdds {
  GPBEnumArray *array = [GPBEnumArray array];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addValue:71];
  XCTAssertEqual(array.count, 1U);

  const int32_t kValues1[] = { 72, 73 };
  [array addValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const int32_t kValues2[] = { 74, 71 };
  GPBEnumArray *array2 =
      [[GPBEnumArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addRawValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  // Zero/nil inputs do nothing.
  [array addValues:kValues1 count:0];
  XCTAssertEqual(array.count, 5U);
  [array addValues:NULL count:5];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 72);
  XCTAssertEqual([array valueAtIndex:2], 73);
  XCTAssertEqual([array valueAtIndex:3], 74);
  XCTAssertEqual([array valueAtIndex:4], 71);
  [array2 release];
}

- (void)testInsert {
  const int32_t kValues[] = { 71, 72, 73 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertValue:74 atIndex:0];
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertValue:74 atIndex:2];
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertValue:74 atIndex:5];
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertValue:74 atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array valueAtIndex:0], 74);
  XCTAssertEqual([array valueAtIndex:1], 71);
  XCTAssertEqual([array valueAtIndex:2], 74);
  XCTAssertEqual([array valueAtIndex:3], 72);
  XCTAssertEqual([array valueAtIndex:4], 73);
  XCTAssertEqual([array valueAtIndex:5], 74);
  [array release];
}

- (void)testRemove {
  const int32_t kValues[] = { 74, 71, 72, 74, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 6U);

  // First
  [array removeValueAtIndex:0];
  XCTAssertEqual(array.count, 5U);
  XCTAssertEqual([array valueAtIndex:0], 71);

  // Middle
  [array removeValueAtIndex:2];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:2], 73);

  // End
  [array removeValueAtIndex:3];
  XCTAssertEqual(array.count, 3U);

  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 72);
  XCTAssertEqual([array valueAtIndex:2], 73);

  // Too far.
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:3],
                               NSException, NSRangeException);

  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  XCTAssertThrowsSpecificNamed([array removeValueAtIndex:0],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInplaceMutation {
  const int32_t kValues[] = { 71, 71, 73, 73 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withValue:72];
  [array replaceValueAtIndex:3 withValue:74];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 72);
  XCTAssertEqual([array valueAtIndex:2], 73);
  XCTAssertEqual([array valueAtIndex:3], 74);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withValue:74],
                               NSException, NSRangeException);

  [array exchangeValueAtIndex:1 withValueAtIndex:3];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 74);
  XCTAssertEqual([array valueAtIndex:2], 73);
  XCTAssertEqual([array valueAtIndex:3], 72);

  [array exchangeValueAtIndex:2 withValueAtIndex:0];
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 73);
  XCTAssertEqual([array valueAtIndex:1], 74);
  XCTAssertEqual([array valueAtIndex:2], 71);
  XCTAssertEqual([array valueAtIndex:3], 72);

  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:4 withValueAtIndex:1],
                               NSException, NSRangeException);
  XCTAssertThrowsSpecificNamed([array exchangeValueAtIndex:1 withValueAtIndex:4],
                               NSException, NSRangeException);
  [array release];
}

- (void)testInternalResizing {
  const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [GPBEnumArray arrayWithCapacity:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  [array addValues:kValues count:GPBARRAYSIZE(kValues)];

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertValue:74 atIndex:(i * 3)];
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
}

@end

//%PDDM-EXPAND-END (8 expansions)

#pragma mark - Non macro-based Enum tests

// These are hand written tests to cover the verification and raw methods.

@interface GPBEnumArrayCustomTests : XCTestCase
@end

@implementation GPBEnumArrayCustomTests

- (void)testRawBasics {
  static const int32_t kValues[] = { 71, 272, 73, 374 };
  static const int32_t kValuesFiltered[] = {
      71, kGPBUnrecognizedEnumeratorValue, 73, kGPBUnrecognizedEnumeratorValue
  };
  XCTAssertEqual(GPBARRAYSIZE(kValues), GPBARRAYSIZE(kValuesFiltered));
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 4U);
  GPBEnumValidationFunc func = TestingEnum_IsValidValue;
  XCTAssertEqual(array.validationFunc, func);
  XCTAssertEqual([array rawValueAtIndex:0], 71);
  XCTAssertEqual([array rawValueAtIndex:1], 272);
  XCTAssertEqual([array valueAtIndex:1], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:2], 73);
  XCTAssertEqual([array rawValueAtIndex:3], 374);
  XCTAssertEqual([array valueAtIndex:3], kGPBUnrecognizedEnumeratorValue);
  XCTAssertThrowsSpecificNamed([array rawValueAtIndex:4], NSException, NSRangeException);
  __block NSUInteger idx2 = 0;
  [array enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValuesFiltered[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateRawValuesWithOptions:NSEnumerationReverse
                            usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateValuesWithOptions:NSEnumerationReverse
                         usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValuesFiltered[idx]);
    XCTAssertNotEqual(stop, NULL);
    ++idx2;
  }];
  // Stopping the enumeration.
  idx2 = 0;
  [array enumerateRawValuesWithBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, idx2);
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 2U);
    XCTAssertNotEqual(idx, 3U);
    ++idx2;
  }];
  idx2 = 0;
  [array enumerateRawValuesWithOptions:NSEnumerationReverse
                            usingBlock:^(int32_t value, NSUInteger idx, BOOL *stop) {
    XCTAssertEqual(idx, (3 - idx2));
    XCTAssertEqual(value, kValues[idx]);
    XCTAssertNotEqual(stop, NULL);
    if (idx2 == 1) *stop = YES;
    XCTAssertNotEqual(idx, 1U);
    XCTAssertNotEqual(idx, 0U);
    ++idx2;
  }];
  [array release];
}

- (void)testEquality {
  const int32_t kValues1[] = { 71, 72, 173 };  // With unknown value
  const int32_t kValues2[] = { 71, 74, 173 };  // With unknown value
  const int32_t kValues3[] = { 71, 72, 173, 74 };  // With unknown value
  GPBEnumArray *array1 =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues1
                                                 count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1);
  GPBEnumArray *array1prime =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue2
                                             rawValues:kValues1
                                                 count:GPBARRAYSIZE(kValues1)];
  XCTAssertNotNil(array1prime);
  GPBEnumArray *array2 =
      [[GPBEnumArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  GPBEnumArray *array3 =
      [[GPBEnumArray alloc] initWithValues:kValues3
                                     count:GPBARRAYSIZE(kValues3)];
  XCTAssertNotNil(array3);

  // 1/1Prime should be different objects, but equal.
  XCTAssertNotEqual(array1, array1prime);
  XCTAssertEqualObjects(array1, array1prime);
  // Equal, so they must have same hash.
  XCTAssertEqual([array1 hash], [array1prime hash]);
  // But different validation functions.
  XCTAssertNotEqual(array1.validationFunc, array1prime.validationFunc);

  // 1/2/3 shouldn't be equal.
  XCTAssertNotEqualObjects(array1, array2);
  XCTAssertNotEqualObjects(array1, array3);
  XCTAssertNotEqualObjects(array2, array3);

  [array1 release];
  [array1prime release];
  [array2 release];
  [array3 release];
}

- (void)testCopy {
  const int32_t kValues[] = { 71, 72 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array addRawValue:1000]; // Unknown
  XCTAssertEqual(array.count, 3U);
  XCTAssertEqual([array rawValueAtIndex:0], 71);
  XCTAssertEqual([array rawValueAtIndex:1], 72);
  XCTAssertEqual([array rawValueAtIndex:2], 1000);
  XCTAssertEqual([array valueAtIndex:2], kGPBUnrecognizedEnumeratorValue);

  GPBEnumArray *array2 = [array copy];
  XCTAssertNotNil(array2);

  // Should be new object but equal.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  XCTAssertEqual(array.validationFunc, array2.validationFunc);
  XCTAssertTrue([array2 isKindOfClass:[GPBEnumArray class]]);
  XCTAssertEqual(array2.count, 3U);
  XCTAssertEqual([array2 rawValueAtIndex:0], 71);
  XCTAssertEqual([array2 rawValueAtIndex:1], 72);
  XCTAssertEqual([array2 rawValueAtIndex:2], 1000);
  XCTAssertEqual([array2 valueAtIndex:2], kGPBUnrecognizedEnumeratorValue);
  [array2 release];
  [array release];
}

- (void)testArrayFromArray {
  const int32_t kValues[] = { 71, 172, 173, 74 };  // Unknowns
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  GPBEnumArray *array2 = [GPBEnumArray arrayWithValueArray:array];
  XCTAssertNotNil(array2);

  // Should be new pointer, but equal objects.
  XCTAssertNotEqual(array, array2);
  XCTAssertEqualObjects(array, array2);
  XCTAssertEqual(array.validationFunc, array2.validationFunc);
  [array release];
}

- (void)testUnknownAdds {
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue];
  XCTAssertNotNil(array);

  XCTAssertThrowsSpecificNamed([array addValue:172],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 0U);

  const int32_t kValues1[] = { 172, 173 };  // Unknown
  XCTAssertThrowsSpecificNamed([array addValues:kValues1 count:GPBARRAYSIZE(kValues1)],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 0U);
  [array release];
}

- (void)testRawAdds {
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue];
  XCTAssertNotNil(array);

  XCTAssertEqual(array.count, 0U);
  [array addRawValue:71];  // Valid
  XCTAssertEqual(array.count, 1U);

  const int32_t kValues1[] = { 172, 173 };  // Unknown
  [array addRawValues:kValues1 count:GPBARRAYSIZE(kValues1)];
  XCTAssertEqual(array.count, 3U);

  const int32_t kValues2[] = { 74, 71 };
  GPBEnumArray *array2 =
      [[GPBEnumArray alloc] initWithValues:kValues2
                                     count:GPBARRAYSIZE(kValues2)];
  XCTAssertNotNil(array2);
  [array addRawValuesFromArray:array2];
  XCTAssertEqual(array.count, 5U);

  XCTAssertEqual([array rawValueAtIndex:0], 71);
  XCTAssertEqual([array rawValueAtIndex:1], 172);
  XCTAssertEqual([array valueAtIndex:1], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:2], 173);
  XCTAssertEqual([array valueAtIndex:2], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:3], 74);
  XCTAssertEqual([array rawValueAtIndex:4], 71);
  [array release];
}

- (void)testUnknownInserts {
  const int32_t kValues[] = { 71, 72, 73 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  XCTAssertThrowsSpecificNamed([array insertValue:174 atIndex:0],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 3U);

  // Middle
  XCTAssertThrowsSpecificNamed([array insertValue:274 atIndex:1],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 3U);

  // End
  XCTAssertThrowsSpecificNamed([array insertValue:374 atIndex:3],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 3U);
  [array release];
}

- (void)testRawInsert {
  const int32_t kValues[] = { 71, 72, 73 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);
  XCTAssertEqual(array.count, 3U);

  // First
  [array insertRawValue:174 atIndex:0];  // Unknown
  XCTAssertEqual(array.count, 4U);

  // Middle
  [array insertRawValue:274 atIndex:2];  // Unknown
  XCTAssertEqual(array.count, 5U);

  // End
  [array insertRawValue:374 atIndex:5];  // Unknown
  XCTAssertEqual(array.count, 6U);

  // Too far.
  XCTAssertThrowsSpecificNamed([array insertRawValue:74 atIndex:7],
                               NSException, NSRangeException);

  XCTAssertEqual([array rawValueAtIndex:0], 174);
  XCTAssertEqual([array valueAtIndex:0], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:1], 71);
  XCTAssertEqual([array rawValueAtIndex:2], 274);
  XCTAssertEqual([array valueAtIndex:2], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:3], 72);
  XCTAssertEqual([array rawValueAtIndex:4], 73);
  XCTAssertEqual([array rawValueAtIndex:5], 374);
  XCTAssertEqual([array valueAtIndex:5], kGPBUnrecognizedEnumeratorValue);
  [array release];
}

- (void)testUnknownInplaceMutation {
  const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:1 withValue:172],
                               NSException, NSInvalidArgumentException);
  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:3 withValue:274],
                               NSException, NSInvalidArgumentException);
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array valueAtIndex:0], 71);
  XCTAssertEqual([array valueAtIndex:1], 72);
  XCTAssertEqual([array valueAtIndex:2], 73);
  XCTAssertEqual([array valueAtIndex:3], 74);
  [array release];
}


- (void)testRawInplaceMutation {
  const int32_t kValues[] = { 71, 72, 73, 74 };
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValidationFunction:TestingEnum_IsValidValue
                                             rawValues:kValues
                                                 count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  [array replaceValueAtIndex:1 withRawValue:172];  // Unknown
  [array replaceValueAtIndex:3 withRawValue:274];  // Unknown
  XCTAssertEqual(array.count, 4U);
  XCTAssertEqual([array rawValueAtIndex:0], 71);
  XCTAssertEqual([array rawValueAtIndex:1], 172);
  XCTAssertEqual([array valueAtIndex:1], kGPBUnrecognizedEnumeratorValue);
  XCTAssertEqual([array rawValueAtIndex:2], 73);
  XCTAssertEqual([array rawValueAtIndex:3], 274);
  XCTAssertEqual([array valueAtIndex:3], kGPBUnrecognizedEnumeratorValue);

  XCTAssertThrowsSpecificNamed([array replaceValueAtIndex:4 withRawValue:74],
                               NSException, NSRangeException);
  [array release];
}

- (void)testRawInternalResizing {
  const int32_t kValues[] = { 71, 172, 173, 74 };  // Unknown
  GPBEnumArray *array =
      [[GPBEnumArray alloc] initWithValues:kValues
                                     count:GPBARRAYSIZE(kValues)];
  XCTAssertNotNil(array);

  // Add/remove to trigger the intneral buffer to grow/shrink.
  for (int i = 0; i < 100; ++i) {
    [array addRawValues:kValues count:GPBARRAYSIZE(kValues)];
  }
  XCTAssertEqual(array.count, 404U);
  for (int i = 0; i < 100; ++i) {
    [array removeValueAtIndex:(i * 2)];
  }
  XCTAssertEqual(array.count, 304U);
  for (int i = 0; i < 100; ++i) {
    [array insertRawValue:274 atIndex:(i * 3)];  // Unknown
  }
  XCTAssertEqual(array.count, 404U);
  [array removeAll];
  XCTAssertEqual(array.count, 0U);
  [array release];
}

@end

#pragma mark - GPBAutocreatedArray Tests

// These are hand written tests to double check some behaviors of the
// GPBAutocreatedArray.

// NOTE: GPBAutocreatedArray is private to the library, users of the library
// should never have to directly deal with this class.

@interface GPBAutocreatedArrayTests : XCTestCase
@end

@implementation GPBAutocreatedArrayTests

- (void)testEquality {
  GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];

  XCTAssertTrue([array isEqual:@[]]);
  XCTAssertTrue([array isEqualToArray:@[]]);

  XCTAssertFalse([array isEqual:@[ @"foo" ]]);
  XCTAssertFalse([array isEqualToArray:@[ @"foo" ]]);

  [array addObject:@"foo"];

  XCTAssertFalse([array isEqual:@[]]);
  XCTAssertFalse([array isEqualToArray:@[]]);
  XCTAssertTrue([array isEqual:@[ @"foo" ]]);
  XCTAssertTrue([array isEqualToArray:@[ @"foo" ]]);
  XCTAssertFalse([array isEqual:@[ @"bar" ]]);
  XCTAssertFalse([array isEqualToArray:@[ @"bar" ]]);

  GPBAutocreatedArray *array2 = [[GPBAutocreatedArray alloc] init];

  XCTAssertFalse([array isEqual:array2]);
  XCTAssertFalse([array isEqualToArray:array2]);

  [array2 addObject:@"bar"];
  XCTAssertFalse([array isEqual:array2]);
  XCTAssertFalse([array isEqualToArray:array2]);

  [array2 replaceObjectAtIndex:0 withObject:@"foo"];
  XCTAssertTrue([array isEqual:array2]);
  XCTAssertTrue([array isEqualToArray:array2]);

  [array2 release];
  [array release];
}

- (void)testCopy {
  {
    GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];

    NSArray *cpy = [array copy];
    XCTAssertTrue(cpy != array); // Ptr compare
    XCTAssertTrue([cpy isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy.count, (NSUInteger)0);

    NSArray *cpy2 = [array copy];
    XCTAssertTrue(cpy2 != array); // Ptr compare
    // Can't compare cpy and cpy2 because NSArray has a singleton empty
    // array it uses, so the ptrs are the same.
    XCTAssertTrue([cpy2 isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy2 isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy2.count, (NSUInteger)0);

    [cpy2 release];
    [cpy release];
    [array release];
  }

  {
    GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];

    NSMutableArray *cpy = [array mutableCopy];
    XCTAssertTrue(cpy != array); // Ptr compare
    XCTAssertTrue([cpy isKindOfClass:[NSMutableArray class]]);
    XCTAssertFalse([cpy isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy.count, (NSUInteger)0);

    NSMutableArray *cpy2 = [array mutableCopy];
    XCTAssertTrue(cpy2 != array); // Ptr compare
    XCTAssertTrue(cpy2 != cpy); // Ptr compare
    XCTAssertTrue([cpy2 isKindOfClass:[NSMutableArray class]]);
    XCTAssertFalse([cpy2 isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy2.count, (NSUInteger)0);

    [cpy2 release];
    [cpy release];
    [array release];
  }

  {
    GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];
    [array addObject:@"foo"];
    [array addObject:@"bar"];

    NSArray *cpy = [array copy];
    XCTAssertTrue(cpy != array); // Ptr compare
    XCTAssertTrue([cpy isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy.count, (NSUInteger)2);
    XCTAssertEqualObjects(cpy[0], @"foo");
    XCTAssertEqualObjects(cpy[1], @"bar");

    NSArray *cpy2 = [array copy];
    XCTAssertTrue(cpy2 != array); // Ptr compare
    XCTAssertTrue(cpy2 != cpy); // Ptr compare
    XCTAssertTrue([cpy2 isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy2 isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy2.count, (NSUInteger)2);
    XCTAssertEqualObjects(cpy2[0], @"foo");
    XCTAssertEqualObjects(cpy2[1], @"bar");

    [cpy2 release];
    [cpy release];
    [array release];
  }

  {
    GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];
    [array addObject:@"foo"];
    [array addObject:@"bar"];

    NSMutableArray *cpy = [array mutableCopy];
    XCTAssertTrue(cpy != array); // Ptr compare
    XCTAssertTrue([cpy isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy.count, (NSUInteger)2);
    XCTAssertEqualObjects(cpy[0], @"foo");
    XCTAssertEqualObjects(cpy[1], @"bar");

    NSMutableArray *cpy2 = [array mutableCopy];
    XCTAssertTrue(cpy2 != array); // Ptr compare
    XCTAssertTrue(cpy2 != cpy); // Ptr compare
    XCTAssertTrue([cpy2 isKindOfClass:[NSArray class]]);
    XCTAssertFalse([cpy2 isKindOfClass:[GPBAutocreatedArray class]]);
    XCTAssertEqual(cpy2.count, (NSUInteger)2);
    XCTAssertEqualObjects(cpy2[0], @"foo");
    XCTAssertEqualObjects(cpy2[1], @"bar");

    [cpy2 release];
    [cpy release];
    [array release];
  }
}

- (void)testIndexedSubscriptSupport {
  // The base NSArray/NSMutableArray behaviors for *IndexedSubscript methods
  // should still work via the methods that one has to override to make an
  // NSMutableArray subclass.  i.e. - this should "just work" and if these
  // crash/fail, then something is wrong in how NSMutableArray is subclassed.

  GPBAutocreatedArray *array = [[GPBAutocreatedArray alloc] init];

  [array addObject:@"foo"];
  [array addObject:@"bar"];
  XCTAssertEqual(array.count, (NSUInteger)2);
  XCTAssertEqualObjects(array[0], @"foo");
  XCTAssertEqualObjects(array[1], @"bar");
  array[0] = @"foo2";
  array[2] = @"baz";
  XCTAssertEqual(array.count, (NSUInteger)3);
  XCTAssertEqualObjects(array[0], @"foo2");
  XCTAssertEqualObjects(array[1], @"bar");
  XCTAssertEqualObjects(array[2], @"baz");

  [array release];
}

@end