QueryLog queryLog = new QueryLog("test query", null);

        assertNotNull(queryLog);
        assertEquals("test query", queryLog.getQueryString());
        assertNull(queryLog.getFilterQueryString());
    }

    @Test
    public void test_getQueryString() throws Exception {
        QueryLog queryLog = new QueryLog("search term", null);

        assertEquals("search term", queryLog.getQueryString());
    }

  fun createFromSslSession() {
    val sslSession =
      FakeSSLSession(
        "TLSv1.3",
        "TLS_AES_128_GCM_SHA256",
        arrayOf(serverCertificate.certificate, serverIntermediate.certificate),
        null,
      )

    val handshake = sslSession.handshake()

    assertThat(handshake.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    assertThat(handshake.cipherSuite).isEqualTo(CipherSuite.TLS_AES_128_GCM_SHA256)

    int expectedHashCode = 0;
    for (E element : elements) {
      expectedHashCode += (element == null) ? 0 : element.hashCode();
    }

    elements.add(null);
    collection = getSubjectGenerator().create(elements.toArray());
    assertEquals(
        "A Set's hashCode() should be the sum of those of its elements (with "
            + "a null element counting as having a hash of zero).",
        expectedHashCode,
        getSet().hashCode());

        }

        @Test
        @DisplayName("Should handle null root cause")
        void testConstructorWithNullRootCause() {
            TransportException exception = new TransportException((Throwable) null);

            assertNotNull(exception);
            assertNull(exception.getRootCause());
        }

        @Test
        @DisplayName("Should handle null message with root cause")

            zipExtractor.setMaxContentSize(100);
            zipExtractor.getText(in, null);
            fail();
        } catch (MaxLengthExceededException e) {
            // pass
        }
        zipExtractor.setMaxContentSize(-1);
    }

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

        CacheRecord(Set<Artifact> artifacts) {
            this.artifacts = artifacts;
            this.exception = null;
        }

        CacheRecord(LifecycleExecutionException exception) {
            this.artifacts = null;
            this.exception = exception;
        }

        public Set<Artifact> getArtifacts() {
            return artifacts;
        }

        if (info != null) {
            System.arraycopy(fileId, 0, info.fileId, 0, 16);
            if (info.type == HandleType.PERSISTENT) {
                persistHandle(info);
            }
        }
    }
    
    public HandleInfo getHandleForReconnect(String path) {
        HandleInfo info = handles.get(path);
        if (info != null && !info.isExpired()) {

          "TLS_NULL_WITH_NULL_NULL", "SSL_NULL_WITH_NULL_NULL" -> {
            throw IOException("cipherSuite == $cipherSuiteString")
          }

          else -> CipherSuite.forJavaName(cipherSuiteString)
        }

      val tlsVersionString = checkNotNull(protocol) { "tlsVersion == null" }

    default void log(@Nonnull Level level, @Nonnull String message) {
        log(level, message, null);
    }

    /**
     * Logs a message at the specified level with an associated exception.
     *
     * @param level the severity level of the message
     * @param message the message to be logged
     * @param error the associated exception, or null if not applicable
     */

            writer.accept("\t\tGoal:                   " + mojoExecId);
        }
        if (mojoExecution.getConfiguration() != null) {
            writer.accept("\t\tConfiguration:          " + mojoExecution.getConfiguration());
        }
        if (mojoExecution.getMojoDescriptor().getDependencyCollectionRequired() != null) {
            writer.accept("\t\tDependencies (collect): "