assertThat(listener.isEmpty()).isTrue();

    Object one = new Object();
    Object two = new Object();
    Object three = new Object();
    Object four = new Object();
    Object five = new Object();
    Object six = new Object();

    map.put(one, two);
    map.remove(one);
    assertNotified(listener, one, two, RemovalCause.EXPLICIT);

        SuggestItem[] items = new SuggestItem[3];
        for (int i = 0; i < 3; i++) {
            String[][] readings = new String[1][];
            readings[0] = new String[] { "query" + i };
            items[i] = new SuggestItem(new String[] { "クエリ" + i }, readings, new String[] { "content" }, 0, 15 + i, -1,

                new SimpleLookup(List.of(
                        new DefaultRequestCacheFactory(),
                        new DefaultRepositoryFactory(new DefaultRemoteRepositoryManager(
                                new DefaultUpdatePolicyAnalyzer(),
                                new DefaultChecksumPolicyProvider(),
                                new DefaultRepositoryKeyFunctionFactory())),

        if (in == null) {
            throw new CrawlerSystemException("LHA archive input stream is null. Cannot extract text from null input.");
        }

        final MimeTypeHelper mimeTypeHelper = getMimeTypeHelper();
        final ExtractorFactory extractorFactory = getExtractorFactory();
        final StringBuilder buf = new StringBuilder(1000);

        File tempFile = null;

  private final ForwardingWrapperTester tester = new ForwardingWrapperTester();

  public void testGoodForwarder() {
    tester.testForwarding(
        Arithmetic.class,
        new Function<Arithmetic, Arithmetic>() {
          @Override
          public Arithmetic apply(Arithmetic arithmetic) {
            return new ForwardingArithmetic(arithmetic);
          }
        });
    tester.testForwarding(

    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);
      out.writeObject(object);
      ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()));
      return (T) requireNonNull(in.readObject());
    } catch (IOException | ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }

	"strings"
	"testing"
)

func BenchmarkRingBuffer_Sync(b *testing.B) {
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	for b.Loop() {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

        Build build = new Build();
        build.setDirectory(expected.substring(0, expected.length() - "/classes".length()));

        Model model = new Model();
        model.setBuild(build);

        MavenProject project = new MavenProject(model);
        project.setFile(new File("pom.xml").getCanonicalFile());

        public boolean isGuest() {
            return this.guest;
        }
    }

    static Stream<boolean[]> anonGuestFlags() {
        return Stream.of(new boolean[] { false, false }, new boolean[] { true, false }, new boolean[] { false, true },
                new boolean[] { true, true });
    }

    @ParameterizedTest
    @MethodSource("anonGuestFlags")
    @DisplayName("unwrap, domain, anonymous/guest flags happy paths")

                if (is == null) {
                    throw new IOException("Resource not found: non/existent/resource.json");
                }
                // This line should not be reached
                new String(is.readAllBytes(), StandardCharsets.UTF_8);
                fail("Should throw IOException for missing resource");
            }