if testCase.expectedErr == nil && err != nil {
			t.Fatalf("Test %d: should succeed but failed with err: %v", i+1, err)
		}
		if testCase.expectedErr != nil && err == nil {
			t.Fatalf("Test %d:, should fail but succeeded.", i+1)
		}
		if err == nil {
			if host != testCase.host {
				t.Fatalf("Test %d: expected: %v, found: %v", i+1, testCase.host, host)
			}
			if port != testCase.port {

            // If it doesn't throw, it should only skip what's available
            assertEquals(3, skipped);
        } catch (IOException e) {
            // This is also acceptable behavior - skip may fail when it runs out of data
            assertTrue(e.getMessage().contains("unexpected EOF"));
        }
    }

    @Test
    @DisplayName("Keep-alive packets are transparently skipped")

        assertTrue(content.contains("tags[0]"));
        assertTrue(content.contains("crawler"));
    }

    public void test_getText_null() {
        try {
            jsonExtractor.getText(null, null);
            fail();
        } catch (final CrawlerSystemException e) {
            // Expected
        }
    }

    public void test_getText_withoutMetadata() {
        jsonExtractor.setExtractMetadata(false);

end }} # connectToMinio # Use a check-sleep-check loop to wait for MinIO service to be available connectToMinio() { SCHEME=$1 ATTEMPTS=0 LIMIT=29 # Allow 30 attempts set -e # fail if we can't read the keys. ACCESS=$(cat /config/rootUser) SECRET=$(cat /config/rootPassword) set +e # The connections to minio are allowed to fail. echo "Connecting to MinIO server: $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT" MC_COMMAND="${MC} alias set myminio $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT $ACCESS $SECRET" $MC_COMMAND...

        help.execute(context);

        // Verify that the plugins option is mentioned in the help output
        Mockito.verify(context.logger).info("      --plugins         Upgrade plugins known to fail with Maven 4");
    }

    @Test
    void testHelpIncludesAllOption() throws Exception {
        UpgradeContext context = createMockContext();

        help.execute(context);

        )
        hasClass<IOException>()
      }
    }
  }

  companion object {
    @AfterClass
    @JvmStatic
    fun resetContext() {
      // Ensure we don't make other tests fail
      Platform.resetForTests()
    }
  }

    @Override
    public void mojoStarted(ExecutionEvent event) {}

    @Override
    public void finish(int exitCode) throws Exception {}

    @Override
    public void fail(Throwable t) throws Exception {}

    @Override
    public void log(String msg) {
        output.accept(msg);
    }

    @Override
    public void transfer(String projectId, TransferEvent e) {}

   *       of the assumption, in which case the equality check before and after serialization will
   *       fail.
   *   <li>If the constructor or factory method takes a parameter that {@link
   *       AbstractPackageSanityTests} doesn't know how to construct, the test will fail.
   *   <li>If there is no visible constructor or visible static factory method declared by {@code

        try {
          ByteStreams.exhaust(decodingStream);
          fail("Expected DecodingException");
        } catch (DecodingException expected) {
          // Don't assert on the expectedMessage; the messages for exceptions thrown from the
          // decoding stream may differ from the messages for the decode methods.
        } catch (IOException e) {
          fail("Expected DecodingException but got: " + e);
        }
      }

import app.cash.burst.Burst
import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.doesNotContain
import assertk.assertions.isEqualTo
import assertk.assertions.startsWith
import assertk.fail
import java.io.IOException
import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit.MILLISECONDS
import javax.net.ServerSocketFactory