*/
    public static FileOutputStream create(final File file) {
        assertArgumentNotNull("file", file);

        try {
            return new FileOutputStream(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Flushes the {@link OutputStream}.
     *
     * @param out the output stream
     */

        // Test valueOf with invalid name throws exception
        try {
            SsoResponseType.valueOf("INVALID");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("INVALID"));
        }
    }

    public void test_valueOf_null() {

          "2c100000e10000003840012750000000e10",
      ),
    )
    try {
      dns.lookup("google.com")
      fail<Any>()
    } catch (uhe: UnknownHostException) {
      assertThat(uhe.message).isEqualTo("google.com: NXDOMAIN")
    }
    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.method).isEqualTo("GET")

    try {
      assertEquals(
          "getOrDefault(null, def) should return default or throw",
          v3(),
          getMap().getOrDefault(null, v3()));
    } catch (NullPointerException tolerated) {
    }
  }

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_nonNullWhenNullContained() {
    initMapWithNullKey();

                    }

                    // In a real implementation, we would process actual change notifications here

                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    if (handle.isActive()) {

            }
        };

        Set<String> roleSet;

        try {
            roleSet = buildByHeader(roleQueryHelperImpl, getMockRequest());
            fail();
        } catch (final NullPointerException e) {
            //ok
        }

        roleQueryHelperImpl.headerKey = "fess1";

        getMockRequest().addHeader("aaa", "bbb");

            if (filename != null && filename.length() > 1) {

                try (FileInputStream in = new FileInputStream(filename)) {
                    p.load(in);
                }
            }

        } catch (final IOException ioe) {
            log.error("Failed to load config", ioe); //$NON-NLS-1$
        }
        p.putAll(System.getProperties());
        if (props != null) {
            p.putAll(props);
        }

                if (logger.isDebugEnabled()) {
                    logger.debug("Logged in as Bind DN. {}", context);
                }
                isBind = true;
            } catch (final Exception e) {
                logger.warn("LDAP configuration is wrong.", e);
            }
        }
        return isBind;
    }

    /**

  public void testRemove_unsupportedNotPresent() {
    try {
      assertFalse(
          "remove(notPresent) should return false or throw UnsupportedOperationException",
          collection.remove(e3()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
    expectMissing(e3());
  }

  @CollectionFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_QUERIES)

        QueryContext context = new QueryContext("test", false);

        try {
            boostQueryCommand.execute(context, termQuery, 1.0f);
            fail("Should have thrown InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
            assertTrue(e.getMessage().contains("TermQuery"));
        }
    }