* reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that
   * a failure that occurs when closing the stream indicates a meaningful problem such as a failure
   * to flush all bytes to the underlying resource.
   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing

        verify(handle, times(1)).hasCapability(captor.capture());
        assertEquals(cap, captor.getValue());
    }

    @Test
    @DisplayName("hasCapability(cap): propagates CIFSException on failure")
    void hasCapability_throws() throws Exception {
        // Arrange
        when(handle.hasCapability(anyInt())).thenThrow(new CIFSException("capability check failed"));

        // Act + Assert

   *   try {
   *     foo.bar();
   *   } catch (BarException | RuntimeException | Error t) {
   *     failure = t;
   *   }
   * }
   * if (failure != null) {
   *   throwIfInstanceOf(failure, BarException.class);
   *   throwIfUnchecked(failure);
   *   throw new AssertionError(failure);
   * }
   * </pre>
   *
   * @since 20.0
   */
  @GwtIncompatible // Class.cast, Class.isInstance

    }

    @Test
    @DisplayName("Test log authentication failure")
    void testLogAuthenticationFailure() {
        logger.logAuthentication(false, "testuser", "DOMAIN", "192.168.1.1");

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_FAILURE), "Should have 1 authentication failure event");
    }

    @Test
    @DisplayName("Test log file access")

			sctx := &serverCtxt{}
			err := mergeServerCtxtFromConfigFile(testcase.config, sctx)
			if testcase.expectedErr && err == nil {
				t.Error("expected failure, got success")
			}
			if !testcase.expectedErr && err != nil {
				t.Error("expected success, got failure", err)
			}
			if err == nil {
				if len(sctx.Layout.pools) != 2 {
					t.Error("expected parsed pools to be 2, not", len(sctx.Layout.pools))
				}

        return new UpgradeResult(processedPoms, modifiedPoms, Collections.emptySet());
    }

    /**
     * Creates a failure result with the specified processed POMs and error POMs.
     */
    public static UpgradeResult failure(Set<Path> processedPoms, Set<Path> errorPoms) {
        return new UpgradeResult(processedPoms, Collections.emptySet(), errorPoms);
    }

    /**

    try {
      testHttpUrl(testData)
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Expected failure but was success: $testData")
      }
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {
        throw e
      }
    }
  }

            testReconnector.testCreateReconnectionRequest(testHandle);
        });
    }

    /**
     * Test implementation of HandleReconnector that allows controlling success/failure
     */
    private static class TestHandleReconnector extends HandleReconnector {
        private final boolean shouldSucceed;

In 12 drive example above, with MinIO server running in the default configuration, you can lose any of the six drives and still reconstruct the data reliably from the remaining drives.

## Why is Erasure Code useful?

labels.errorName=Error Name
labels.expiredTime=Expired Time
labels.expires=Expires
labels.failureCountThreshold=Failure Count
labels.fileConfigName=File Crawl Config Name
labels.fileName=File Name
labels.handlerName=Handler Name
labels.handlerParameter=Parameter
labels.handlerScript=Script
labels.popularWord=Popular Word
labels.ignoreFailureType=Ignored Failure Type
labels.lastAccessTime=Last Access Time
labels.notificationTo=Notification To
labels.num=Num