}
        return false;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return iterators[index].next();
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

 */
public class SuggestSettingsBuilder {
    /**
     * Constructs a new {@link SuggestSettingsBuilder}.
     */
    public SuggestSettingsBuilder() {
        // nothing
    }

    /** The settings index name. */
    protected String settingsIndexName = "fess_suggest";

    /** The timeout settings. */
    protected TimeoutSettings timeoutSettings = new TimeoutSettings();

    /** The initial settings. */

   */

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    checkNotClosed();
    // It turns out that creating a new String is usually as fast, or faster
    // than wrapping cbuf in a light-weight CharSequence.
    target.append(new String(cbuf, off, len));
  }

  /*
   * Override a few functions for performance reasons to avoid creating unnecessary strings.
   */

  @Override

                        handler.isIncludesDependencies(),
                        handler.isAddedToClasspath()
                                ? new JavaPathType[] {JavaPathType.CLASSES, JavaPathType.MODULES}
                                : new JavaPathType[] {});
            }
            return type;
        });
    }

            try (InputStream is = Files.newInputStream(pom)) {
                MavenStaxReader reader = new MavenStaxReader();
                reader.setAddLocationInformation(false);
                reader.read(is, true, InputSource.of("id", pom.toString()));
                i++;
            } catch (XMLStreamException e) {
                throw new RuntimeException("Error parsing: " + pom, e);
            }
        }
        return i;
    }

        assertArgumentNotEmpty("name", name);

        try {
            final Enumeration<URL> e = loader.getResources(name);
            return new EnumerationIterator<>(e);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Loads the class with the specified binary name.
     *
     * @param loader

    private SmartProjectComparator comparator;
    private ProjectDependencyGraph dependencyGraph;

    @BeforeEach
    void setUp() {
        dependencyGraph = new ProjectDependencyGraphStub();
        comparator = new SmartProjectComparator(dependencyGraph);
    }

    @Test
    void testProjectWeightCalculation() {
        // Test that projects with longer downstream chains get higher weights

		}
	}

	path := filepath.Join(w.opts.Directory, w.opts.FileNameFunc())
	f, err := newFile(path)
	if err != nil {
		return fmt.Errorf("unable to create new file at %v: %w", path, err)
	}

	w.f = f

	return nil
}

// NewDir creates a new concurrency safe Writer which performs log rotation.
func NewDir(opts Options) (io.WriteCloser, error) {
	if err := os.MkdirAll(opts.Directory, os.ModePerm); err != nil {

            ByteBuffer buffer = invocation.getArgument(0);
            EnumSet<RdmaAccess> access = invocation.getArgument(1);
            return new TcpMemoryRegion(buffer, access);
        });

        bufferManager = new RdmaBufferManager(mockProvider);
    }

    @AfterEach
    public void tearDown() throws Exception {
        if (bufferManager != null) {
            bufferManager.cleanup();

            this.dataBytesWritten = bytes;
        }
    }

    @BeforeEach
    void setUp() {
        transaction = new TestSmbComTransaction();
        transaction.command = ServerMessageBlock.SMB_COM_TRANSACTION;
        transaction.name = "\\PIPE\\test";
        transaction.txn_buf = new byte[1024];
        transaction.maxBufferSize = 1024;
    }

    @Test
    @DisplayName("Test reset() method resets transaction state")