}
            }
        }
    }

    protected String replaceCiFriendlyVersion(TransformerContext context, String version) {
        if (version != null) {
            for (String key : Arrays.asList("changelist", "revision", "sha1")) {
                String val = context.getUserProperty(key);
                if (val != null) {
                    version = version.replace("${" + key + "}", val);
                }

        assertEquals(66L, MemoryUtil.sizeOf(new String[] { "1234567890" }));
        assertEquals(132L, MemoryUtil.sizeOf(new String[] { "1234567890", "1234567890" }));
        assertEquals(132L, MemoryUtil.sizeOf(Lists.asList("1234567890", new String[] { "1234567890" })));
        assertEquals(132L, MemoryUtil.sizeOf(Maps.map("1234567890", "1234567890").$()));
    }

    private long getObjectSize(Object value) {

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public Collection<Type> provides() {
        return (Collection) types();
    }

    public Collection<DefaultType> types() {
        return Arrays.asList(
                // Maven types
                new DefaultType(Type.POM, Language.NONE, "pom", null, false),
                new DefaultType(Type.BOM, Language.NONE, "pom", null, false),

    )
    client =
      client.newBuilder()
        .protocols(Arrays.asList(Protocol.HTTP_1_1))
        .build()
    assertContent("A", getResponse(newRequest("/")))
  }

  @Test
  fun setProtocolsWithoutHttp11() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()
        .protocols(Arrays.asList(Protocol.HTTP_2))
    }
  }

  @Test

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect.testing;

import static java.util.Arrays.asList;
import static java.util.Collections.emptyMap;
import static java.util.Collections.emptySet;
import static java.util.Collections.singletonMap;
import static java.util.Collections.unmodifiableMap;

import static com.google.common.collect.testing.features.CollectionSize.ZERO;
import static com.google.common.collect.testing.google.ReflectionFreeAssertThrows.assertThrows;
import static java.util.Arrays.asList;
import static java.util.Collections.nCopies;
import static java.util.Collections.singletonList;
import static java.util.Collections.sort;

import com.google.common.annotations.GwtCompatible;

        ImmutableTypeToInstanceMap.<Iterable<?>[]>builder().put(type, array).build();
    assertEquals(1, map.size());
    // Redundant cast works around a javac bug.
    assertThat((Iterable<?>[]) map.getInstance(type)).asList().containsExactly(array[0]);
  }

  public void testWildcardType() {
    TypeToken<ImmutableList<?>> type = new TypeToken<ImmutableList<?>>() {};
    ImmutableTypeToInstanceMap<Iterable<?>> map =

    this.mapCache = mapCache;
  }

  @Parameters
  public static Collection<Object[]> parameters() {
    Comparator<String> nullsLast = Ordering.natural().nullsLast();

    return Arrays.asList(
        new Object[][] {
          {new MapIteratorCache<String, String>(new HashMap<String, String>())},
          {new MapIteratorCache<String, String>(new TreeMap<String, String>(nullsLast))},

    rangeSet.add(Range.closed(3, 10));
    rangeSet.addAll(asList(Range.open(1, 3), Range.closed(5, 8), Range.closed(9, 11)));
    assertThat(rangeSet.asRanges()).containsExactly(Range.openClosed(1, 11)).inOrder();
  }

  public void testRemoveAll() {
    RangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(3, 10));
    rangeSet.removeAll(asList(Range.open(1, 3), Range.closed(5, 8), Range.closed(9, 11)));

        req3.setArtifact(new DefaultArtifact("ut.simple:artifact:zip:classifier:1.0"));
        req3.addRepository(newTestRepository());

        List<ArtifactRequest> requests = Arrays.asList(req1, req2, req3);

        List<ArtifactResult> results = system.resolveArtifacts(session, requests);

        assertEquals(3, results.size());
        checkArtifactResult(results.get(0), "artifact-1.0.jar");