private final int columnNumber;

    private final String message;

    private final Exception exception;

    private final Severity severity;

    /**
     * Creates a new problem with the specified message and exception.
     * Either {@code message} or {@code exception} is required
     *
     * @param message The message describing the problem, may be {@code null}.

import org.junit.Test;

public class HankakuKanaToZenkakuKanaTest {

    @Test
    public void test_constructor() throws Exception {
        HankakuKanaToZenkakuKana normalizer = new HankakuKanaToZenkakuKana();
        assertNotNull(normalizer);
    }

    @Test
    public void test_basicKatakana() throws Exception {
        HankakuKanaToZenkakuKana normalizer = new HankakuKanaToZenkakuKana();

    public void testGet() throws Exception {
        final BeanMap map = new BeanMap();
        map.put("aaa", 1);
        map.put("bbb", 2);
        assertThat(map.get("aaa"), is((Object) 1));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet_NotContains() throws Exception {
        exception.expect(IllegalKeyOfBeanMapException.class);

        // Try to execute - should be blocked with CIFSException
        CIFSException exception = assertThrows(CIFSException.class, () -> {
            circuitBreaker.executeWithCircuitBreaker(() -> "should not execute");
        }, "Circuit breaker should throw CIFSException when open");

        assertTrue(exception.getMessage().contains("Circuit breaker 'test' is open"), "Exception message should indicate circuit is open");
    }

    @Test

    verifyThreadWasNotInterrupted();
  }

  public void testFailed() throws Exception {
    Exception e = new Exception();
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                throw e;
              }
            });
    task.run();

     * Logs a debug message with an associated exception.
     *
     * @param message the debug message to be logged
     * @param error the associated exception
     */
    default void debug(@Nonnull String message, @Nullable Throwable error) {
        log(Level.DEBUG, message, error);
    }

    /**
     * Logs an info message without an associated exception.
     *
     * @param message the info message to be logged
     */

/**
 * Classes and futures used in {@link FuturesGetCheckedTest} and {@link FuturesGetUncheckedTest}.
 */
@GwtCompatible
@NullUnmarked
final class FuturesGetCheckedInputs {
  static final Exception CHECKED_EXCEPTION = new Exception("mymessage");
  static final Future<String> FAILED_FUTURE_CHECKED_EXCEPTION =
      immediateFailedFuture(CHECKED_EXCEPTION);
  static final RuntimeException UNCHECKED_EXCEPTION = new RuntimeException("mymessage");

@NullUnmarked
public class SingleThreadAbstractFutureBenchmark {
  @Param Impl impl;

  private final Exception exception = new Exception();
  private Facade<?> notDoneFuture;

  @BeforeExperiment
  void setUp() throws Exception {
    notDoneFuture = impl.newFacade();
  }

  @Benchmark
  public long timeComplete_Normal(int reps) throws Exception {
    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);

    }

    @Test
    public void testContentException() {
        CurlResponse response = new CurlResponse();
        Exception exception = new IOException("Test exception");

        response.setContentException(exception);

        assertSame(exception, response.getContentException());
    }

    @Test
    public void testHeaders() {
        CurlResponse response = new CurlResponse();

        }

        @Test
        void testGuice() throws Exception {
            List<Binding<ModelParser>> parsers =
                    container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
            assertNotNull(parsers);
            assertEquals(1, parsers.size());
        }

        @Test
        void testDI() throws Exception {
            DiInjected diInjected = new DiInjected();