// Node/edge sets are the same, but node/edge connections differ due to edge type.
  @Test
  public void equivalent_directedVsUndirected() {
    network.addEdge(N1, N2, E12);

    MutableNetwork<Integer, String> g2 = createNetwork(oppositeType(edgeType));
    g2.addEdge(N1, N2, E12);

    assertThat(network).isNotEqualTo(g2);
  }

  // Node/edge sets and node/edge connections are the same, but directedness differs.
  @Test

}

kotlin {
    compilerOptions {
        allWarningsAsErrors = true
        jvmTarget.set(JvmTarget.JVM_1_8)
    }
}

detekt {
    // overwrite the config file's location
    config.convention(project.isolated.rootProject.projectDirectory.file("../gradle/detekt.yml"))

      ),
      panels.timeSeries.base(
        'Events', queries.pilotEvents, |||
          Size of each xDS push.
        |||
      ),
      panels.timeSeries.base(
        'Connections', queries.xdsConnections, |||
          Total number of XDS connections
        |||
      ),
      panels.timeSeries.base(
        'Push Errors', queries.xdsErrors, |||

   *
   * In part because Cells are relatively large, we avoid creating
   * them until they are needed.  When there is no contention, all
   * updates are made to the base field.  Upon first contention (a
   * failed CAS on base update), the table is initialized to size 2.
   * The table size is doubled upon further contention until
   * reaching the nearest power of two greater than or equal to the

     *   increase availability of multi-homed services.
     *
     * * **Stale pooled connections.** The [ConnectionPool] reuses sockets
     *   to decrease request latency, but these connections will occasionally time out.
     *
     * * **Unreachable proxy servers.** A [ProxySelector] can be used to

      allocationLimit = settings.getMaxConcurrentStreams()

      if (allocationLimit < oldLimit) {
        // We might need new connections to keep policies satisfied
        connectionPool.scheduleOpener(route.address)
      } else if (allocationLimit > oldLimit) {
        // We might no longer need some connections
        connectionPool.scheduleCloser()
      }
    }
  }

  override fun handshake(): Handshake? = handshake

          'pilot_xds_push_context_errors'
        ),
      ],

      xdsConnections: [
        self.query(
          'Connections (client reported)',
          'sum(envoy_cluster_upstream_cx_active{cluster_name="xds-grpc"})'
        ),
        self.query(
          'Connections (server reported)',
          sum('pilot_xds')
        ),
      ],

      pushTime:
        self.query(
          '{{le}}',

 * sum that is used for purposes such as collecting statistics, not for fine-grained synchronization
 * control. Under low update contention, the two classes have similar characteristics. But under
 * high contention, expected throughput of this class is significantly higher, at the expense of
 * higher space consumption.
 *
 * <p>This class extends {@link Number}, but does not define methods such as {@code

bookinfo      bookinfo-rev           rev1         True
bookinfo      bookinfo-valid         default      True
default       bookinfo               default      False
default       no-name-convention     default      True

plugins {
    id("io.gitlab.arturbosch.detekt")
}

detekt {
    // enable all default rules
    buildUponDefaultConfig = true

    // customize some of the rules, until we can fix the offending cases
    config.convention(project.isolated.rootProject.projectDirectory.file("gradle/detekt.yml"))

    // also check the project build file
    source.from(project.buildFile)
}

pluginManager.withPlugin("gradlebuild.code-quality") {