n.Erasure = fi.Erasure
	return
}

// WriteQuorum returns expected write quorum for this FileInfo
func (fi FileInfo) WriteQuorum(dquorum int) int {
	if fi.Deleted {
		return dquorum
	}
	quorum := fi.Erasure.DataBlocks
	if fi.Erasure.DataBlocks == fi.Erasure.ParityBlocks {
		quorum++
	}
	return quorum
}

// ReadQuorum returns expected read quorum for this FileInfo

        ),
      )
      .assertLogMatch(
        Regex(

				ChainedCNIPlugin: c.chainedCNIPlugin,
			}
			err := checkValidCNIConfig(cfg, filepath.Join(tempDir, c.cniConfigFilename))
			if (c.expectedFailure && err == nil) || (!c.expectedFailure && err != nil) {
				t.Fatalf("expected failure: %t, got %v", c.expectedFailure, err)
			}
		})
	}
}

func TestSleepCheckInstall(t *testing.T) {
	cases := []struct {
		name                  string
		chainedCNIPlugin      bool

 * remove) are supported. Null keys and values are supported.
 *
 * <p>{@code containsKey(k)}, {@code put(k, v)} and {@code remove(k)} are all (expected and
 * amortized) constant time operations. Expected in the hashtable sense (depends on the hash
 * function doing a good job of distributing the elements to the buckets to a distribution not far

    assertLessThan(STOPPING, TERMINATED);
  }

  private static <T extends Comparable<? super T>> void assertLessThan(T a, T b) {
    if (a.compareTo(b) >= 0) {
      fail(String.format(Locale.ROOT, "Expected %s to be less than %s", a, b));
    }
  }

	registerStringParameter(constants.RepairInitTerminationMsg, "",
		"The expected termination message for the init container when crash-looping because of CNI misconfiguration")
	registerIntegerParameter(constants.RepairInitExitCode, iptables.ValidationErrorCode,
		"Expected exit code for the init container when crash-looping because of CNI misconfiguration")

      }
      try {
        int maxSize = digest.getDigestLength();
        new MessageDigestHashFunction(algorithmName, maxSize + 1, algorithmName);
        fail();
      } catch (IllegalArgumentException expected) {
      }
    } catch (NoSuchAlgorithmException nsae) {
      throw new AssertionError(nsae);
    }
  }

      client.newCall(
        Request.Builder()
          .url(server!!.url("/"))
          .build(),
      )
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isIn("timeout", "Read timed out")
    }
    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",

    source1.close() // Not exhausted!
    assertThat(relay1.isClosed).isTrue()
    assertFailsWith<IOException> {
      read(file)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("unreadable cache file")
    }
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun redundantCallsToCloseAreIgnored() {
    val upstream = Buffer()

   */
  @CanIgnoreReturnValue
  public NetworkBuilder<N, E> allowsSelfLoops(boolean allowsSelfLoops) {
    this.allowsSelfLoops = allowsSelfLoops;
    return this;
  }

  /**
   * Specifies the expected number of nodes in the network.
   *
   * @throws IllegalArgumentException if {@code expectedNodeCount} is negative
   */
  @CanIgnoreReturnValue
  public NetworkBuilder<N, E> expectedNodeCount(int expectedNodeCount) {