assertEquals(
        "Modifying the builder should not have changed any already built sets",
        216,
        webSafeColors.size());
    assertEquals("the new array should be one bigger than webSafeColors", 217, addedColor.size());
    Integer[] appendColorArray = addedColor.toArray(new Integer[addedColor.size()]);
    assertEquals(0x00BFFF, (int) appendColorArray[216]);
  }

  public void testBuilderAddHandlesNullsCorrectly() {

  }

  @Override
  public boolean containsAll(Collection<?> targets) {
    return delegate.containsAll(targets);
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override

  @WeakOuter
  final class Values extends AbstractCollection<V> {
    @Override
    public Iterator<V> iterator() {
      return valueIterator();
    }

    @Override
    public int size() {
      return AbstractMultimap.this.size();
    }

    @Override
    public boolean contains(@Nullable Object o) {
      return AbstractMultimap.this.containsValue(o);
    }

    @Override
    public void clear() {

        config.winsServer = new InetAddress[0];
        config.initResolverOrder(null);

        List<ResolverType> order = config.getResolveOrder();
        assertEquals(3, order.size());
        assertEquals(ResolverType.RESOLVER_LMHOSTS, order.get(0));
        assertEquals(ResolverType.RESOLVER_DNS, order.get(1));
        assertEquals(ResolverType.RESOLVER_BCAST, order.get(2));
    }

    @Test

		}
		relation.Polymorphic.PolymorphicID.GORMDataType = primaryKeyField.GORMDataType
		if relation.Polymorphic.PolymorphicID.Size == 0 {
			relation.Polymorphic.PolymorphicID.Size = primaryKeyField.Size
		}

		relation.References = append(relation.References, &Reference{
			PrimaryKey:    primaryKeyField,
			ForeignKey:    relation.Polymorphic.PolymorphicID,

		ID   uint
		Name string
		Size string
	}
	dryRunDB := DB.Session(&gorm.Session{DryRun: true})

	stmt := dryRunDB.Where(
		DB.Where("pizza = ?", "pepperoni").Where(DB.Where("size = ?", "small").Or("size = ?", "medium")),
	).Or(
		DB.Where("pizza = ?", "hawaiian").Where("size = ?", "xlarge"),
	).Find(&Pizza{}).Statement

                return fieldSet;
            }
        };
        ComponentUtil.register(mockConfig, "fessConfig");

        assertEquals(2, mockConfig.getApiPingEsFieldSet().size());
        assertTrue(mockConfig.getApiPingEsFieldSet().contains("cluster_name"));
        assertTrue(mockConfig.getApiPingEsFieldSet().contains("status"));
    }

    public void test_emptyFieldSet() {

          extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemove() {
    assertContentsInOrder(multimap().asMap().remove(k0()), v0());
    assertGet(k0());
    assertEquals(getNumElements() - 1, multimap().size());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_PUT)
  public void testAsMapEntrySetReflectsPutSameKey() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()));

        this.path = filename;
        this.maxReferralLevel = maxReferralLevel;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 4 + 2 * this.path.length();
    }

    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;