}

    @Test
    void testBuild() {
        Model model = new Model();
        Build build = new Build();
        build.setOutputDirectory("myOutputDirectory");
        model.setBuild(build);
        Build build2 = model.getBuild();
        assertNotNull(build2);
        assertEquals("myOutputDirectory", build2.getOutputDirectory());
        model.setBuild(null);
        assertNull(model.getBuild());
    }

      .eventListenerFactory(eventListenerFactory)
      .build()

  fun run() {
    // Launch wireshark in the background
    val process = eventListenerFactory.launchWireShark()

    val fbRequest =
      Request
        .Builder()
        .url("https://graph.facebook.com/robots.txt?s=fb")
        .build()
    val twitterRequest =
      Request
        .Builder()
        .url("https://api.twitter.com/robots.txt?s=tw")

    {
      ImmutableSet.Builder<String> builder = this.<String>builder();
      assertThrows(NullPointerException.class, () -> builder.add((String) null));
    }

    {
      ImmutableSet.Builder<String> builder = this.<String>builder();
      assertThrows(NullPointerException.class, () -> builder.add((String[]) null));
    }

    {
      ImmutableSet.Builder<String> builder = this.<String>builder();

        return collect(
                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.COLLECT, root, scope));
    }

    /**
     * Collects the transitive dependencies of some artifacts and builds a dependency graph for the given path scope.

public final class WebSocketEcho extends WebSocketListener {
  private void run() {
    OkHttpClient client = new OkHttpClient.Builder()
        .readTimeout(0,  TimeUnit.MILLISECONDS)
        .build();

    Request request = new Request.Builder()
        .url("ws://echo.websocket.org")
        .build();
    client.newWebSocket(request, this);

    // Trigger shutdown of the dispatcher's executor so this process exits immediately.

                    ImmutableClassToInstanceMap.Builder<Impl> builder =
                        ImmutableClassToInstanceMap.builder();
                    for (Object object : elements) {
                      Entry<?, ?> entry = (Entry<?, ?>) object;
                      builder.put((Class) entry.getKey(), (Impl) entry.getValue());
                    }
                    return (Map) builder.build();
                  }
                })

  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()

  val client = bootstrapClient.newBuilder().dns(dns).build()
```

 */
public class OkHttpCaller {
  public static Call callOkHttp(HttpUrl url) {
    OkHttpClient client = new OkHttpClient
      .Builder()
      .eventListenerFactory(new LoggingEventListener.Factory(HttpLoggingInterceptor.Logger.DEFAULT))
      .build();
    return client.newCall(new Request.Builder().url(url).build());
  }

    for (CacheBuilder<Object, Object> builder : cacheFactory().buildAllPermutations()) {
      // all caches should be different: instance equality
      new EqualsTester()
          .addEqualityGroup(builder.build(identityLoader()))
          .addEqualityGroup(builder.build(identityLoader()))
          .addEqualityGroup(builder.build(identityLoader()))
          .testEquals();
    }
  }

    ImmutableSortedSet.Builder<LegacyComparable> builder =
        ImmutableSortedSet.<LegacyComparable>naturalOrder();

    builder.addAll(LegacyComparable.VALUES_BACKWARD);
    builder.add(LegacyComparable.X);
    builder.add(LegacyComparable.Y, LegacyComparable.Z);

    ImmutableSortedSet<LegacyComparable> set = builder.build();
    assertTrue(elementsEqual(LegacyComparable.VALUES_FORWARD, set));