.createTestSuite();
  }

  // TODO: consider being null-hostile in these tests

  private static Test testsForHashMapNullKeysForbidden() {
    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override
          Map<String, String> wrap(HashMap<String, String> map) {
            if (map.containsKey(null)) {
              throw new NullPointerException();
            }

        // Tests will not supply these
        this.mainApiChangesJsonFile = params.get("mainApiChangesJsonFile") ? new File(params.get("mainApiChangesJsonFile") as String) : null
        this.projectRootDir = params.get("projectRootDir") ? new File(params.get("projectRootDir") as String) : null
    }

    protected BinaryCompatibilityRepository getRepository() {

        ) {}

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }

    val sslContext =
      Platform.get().newSSLContext().apply {
        init(null, arrayOf(trustManager), null)
      }
    val sslSocketFactory = sslContext.socketFactory

    val hostnameVerifier = HostnameVerifier { _, _ -> true }

    client =
      client
        .newBuilder()

{"request":{"uri":"/2","header":{}}}`,
		},
		{
			name:  "is-not-missing-null",
			query: `select * from s3object[*] as s where s.request.header is not missing`,
			wantResult: `{"request":{"uri":"/1","header":{"User-Agent":"test"}}}
{"request":{"uri":"/2","header":null}}`,
			withJSON: `{"request":{"uri":"/1","header":{"User-Agent":"test"}}}
{"request":{"uri":"/2","header":null}}`,
		},
		{
			name:       "is-not-missing",

     * the case of <code>smb://</code>, <code>smb://workgroup/</code>,
     * and <code>smb://server/</code> URLs which do not specify a share,
     * <code>null</code> will be returned.
     *
     * @return The share component or <code>null</code> if there is no share
     */
    String getShare();

    /**

                    BadWord badWord = badWordBhv.selectEntity(cb -> cb.query().setSuggestWord_Equal(target)).orElse(null);//TODO
                    final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();
                    if (isDelete) {
                        badWordBhv.delete(badWord);
                    } else if (badWord == null) {
                        badWord = new BadWord();

        if (!config.isDfsDisabled()) {
            this.capabilities |= Smb2Constants.SMB2_GLOBAL_CAP_DFS;
        }

        if (config.isEncryptionEnabled() && config.getMaximumVersion() != null
                && config.getMaximumVersion().atLeast(DialectVersion.SMB300)) {
            this.capabilities |= Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION;
        }

        final Set<DialectVersion> dvs =

    val sslContext2 = get().newSSLContext()
    sslContext2.init(null, null, null)
    val sslSocketFactory2 = sslContext2.socketFactory
    val trustManagerFactory =
      TrustManagerFactory.getInstance(
        TrustManagerFactory.getDefaultAlgorithm(),
      )
    trustManagerFactory.init(null as KeyStore?)
    val trustManager = trustManagerFactory.trustManagers[0] as X509TrustManager
    client =

    }

    @Test
    @DisplayName("Should work with null server name")
    void shouldHandleNullServerName() {
        // When
        MsrpcSamrConnect2 msrpcSamrConnect2 = new MsrpcSamrConnect2(null, testAccess, mockPolicyHandle);

        // Then
        assertNotNull(msrpcSamrConnect2, "Should handle null server name");
    }

    @Test
    @DisplayName("Should work with different access masks")

    assertSame(canonical, pool.intern(not));
  }

  public void testStrong_null() {
    Interner<String> pool = Interners.newStrongInterner();
    assertThrows(NullPointerException.class, () -> pool.intern(null));
  }

  public void testStrong_builder() {
    int concurrencyLevel = 42;
    Interner<Object> interner =
        Interners.newBuilder().strong().concurrencyLevel(concurrencyLevel).build();