}
    this.safeMin = safeMin;
    this.safeMax = safeMax;

    // This is a bit of a hack but lets us do quicker per-character checks in
    // the fast path code. The safe min/max values are very unlikely to extend
    // into the range of surrogate characters, but if they do we must not test
    // any values in that range. To see why, consider the case where:
    // safeMin <= {hi,lo} <= safeMax

        // if removeAll returns true, all we really know is that at least one subscriber was
        // removed... however, barring something very strange we can assume that if at least one
        // subscriber was removed, all subscribers on listener for that event type were... after
        // all, the definition of subscribers on a particular class is totally static

        // Verify that exception is serializable
        assertTrue(exception instanceof java.io.Serializable);
    }

    public void test_longMessage() {
        // Setup - test with a very long message
        final StringBuilder longMessageBuilder = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            longMessageBuilder.append("Query segment ").append(i).append("; ");
        }

Start your application and go to <a href="http://127.0.0.1:8000/static/redoc.standalone.js" class="external-link" target="_blank">http://127.0.0.1:8000/static/redoc.standalone.js</a>.

You should see a very long JavaScript file for **ReDoc**.

It could start with something like:

```JavaScript
/*! For license information please see redoc.standalone.js.LICENSE.txt */

        assertNull(decrypted, "Decrypting null should return null");
    }

    @Test
    public void testEncryptDecryptLongPassword() throws Exception {
        // Test with very long password
        char[] plaintext = new char[10000];
        Arrays.fill(plaintext, 'X');

        byte[] encrypted = storage.encryptCredentials(plaintext);

// if the status is not ok.
TF_CAPI_EXPORT extern int TF_OpIsStateful(const char* op_type,
                                          TF_Status* status);

// Platform specific initialization routine. Very few platforms actually require
// this to be called.
TF_CAPI_EXPORT void TF_InitMain(const char* usage, int* argc, char*** argv);

// Platform-specific implementation to return an unused port. (This should used

 *
 * <h3>Invertibility</h3>
 *
 * <p>The reverse operation <b>may</b> be a strict <i>inverse</i> (meaning that {@code
 * converter.reverse().convert(converter.convert(a)).equals(a)} is always true). However, it is very
 * common (perhaps <i>more</i> common) for round-trip conversion to be <i>lossy</i>. Consider an
 * example round-trip using {@link com.google.common.primitives.Doubles#stringConverter}:
 *
 * <ol>

            assertNull("Thread " + i + " threw exception", exceptions[i]);
            assertNotNull("Thread " + i + " failed to create provider", providers[i]);
        }
    }

    // Test with very large time adjustment values
    public void test_largeTimeAdjustmentValues() {
        // Test with milliseconds in a year
        long yearInMillis = 365L * 24L * 60L * 60L * 1000L;

        assertArrayEquals(nameBytes, encodedName);
    }

    @Test
    @DisplayName("Test with long pipe name")
    void testWithLongPipeName() {
        // Test with a very long pipe name
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            sb.append("LongPipeName");
        }
        String pipeName = sb.toString();

        };

        try {
            JobProcess jobProcess = processHelper.startProcess(sessionId, cmdList, pbCall);
            assertNotNull(jobProcess);

            // Echo command completes very quickly, so we just ensure no exceptions
            // Wait for the process to complete
            Thread.sleep(100);

            // Clean up
            processHelper.destroyProcess(sessionId);