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);

        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

          return new IteratorWithJdkBug6529795<>(iterator);
        }
      }.test();
    } catch (AssertionError e) {
      return;
    }
    fail("Should have caught jdk6 bug in target iterator");
  }

  private static final int STEPS = 3;

  static class TesterThatCountsCalls extends IteratorTester<Integer> {
    TesterThatCountsCalls() {

permissions:
  contents: read

jobs:
  build:
    if: github.repository == 'tensorflow/tensorflow' # Don't do this in forks
    runs-on: [self-hosted, linux, ARM64]
    strategy:
      fail-fast: false
      matrix:
        pyver: ['3.9', '3.10', '3.11', '3.12']
    steps:
      - name: Stop old running containers (if any)
        shell: bash
        run: |

  private UncaughtExceptionHandlers() {}

  /**
   * Returns an exception handler that exits the system. This is particularly useful for the main
   * thread, which may start up other, non-daemon threads, but fail to fully initialize the
   * application successfully.
   *
   * <p>Example usage:
   *
   * <pre>
   * public static void main(String[] args) {