len--;
            final int size = len * 2;
            try {
                if (size < 0 || size > 0xFFFF) {
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                }
                val = new String(buf, i, size, "UTF-16LE");
                i += size + 2;
            } catch (final UnsupportedEncodingException uee) {}
        }
        advance(i - index);

        runner.close();
        runner.clean();
    }

    @Before
    public void setUp() {
        builder = new SuggestSettingsBuilder();
    }

    @Test
    public void testConstructor() {
        // Test default constructor
        SuggestSettingsBuilder testBuilder = new SuggestSettingsBuilder();
        assertNotNull(testBuilder);
        assertEquals("fess_suggest", testBuilder.settingsIndexName);

        }
        dictionaryManager.addCreator(this);
    }

    /**
     * Creates a new {@link StemmerOverrideFile} instance.
     *
     * @param id        The unique identifier for the dictionary file.
     * @param path      The file path of the dictionary.
     * @param timestamp The last modified timestamp of the file.
     * @return A new {@link StemmerOverrideFile} associated with the dictionary manager.
     */
    @Override

    /**
     * Constructs a new FessSystemException with the specified detail message and cause.
     *
     * @param message the detail message describing the exception
     * @param cause the cause of this exception
     */
    public FessSystemException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new FessSystemException with the specified detail message.

    abstract List<StackTraceElement> getStackTrace(Throwable t);
  }

  @BeforeExperiment
  public void doBefore() {
    recursionCount = stackDepth - new Throwable().getStackTrace().length - 1;
    if (recursionCount < 0) {
      throw new SkipThisScenarioException();
    }
  }

  @Benchmark
  public boolean timeFindCaller(int reps) {
    return timeFindCaller(reps, recursionCount);
  }

    abstract List<StackTraceElement> getStackTrace(Throwable t);
  }

  @BeforeExperiment
  public void doBefore() {
    recursionCount = stackDepth - new Throwable().getStackTrace().length - 1;
    if (recursionCount < 0) {
      throw new SkipThisScenarioException();
    }
  }

  @Benchmark
  public boolean timeFindCaller(int reps) {
    return timeFindCaller(reps, recursionCount);
  }

 */
@GwtCompatible
public abstract class AbstractSequentialIterator<T> extends UnmodifiableIterator<T> {
  private @Nullable T nextOrNull;

  /**
   * Creates a new iterator with the given first element, or, if {@code firstOrNull} is null,
   * creates a new empty iterator.
   */
  protected AbstractSequentialIterator(@Nullable T firstOrNull) {
    this.nextOrNull = firstOrNull;
  }

  /**

package zip_test

import (
	"archive/zip"
	"bytes"
	"compress/flate"
	"fmt"
	"io"
	"log"
	"os"
)

func ExampleWriter() {
	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Add some files to the archive.
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},

 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class BigIntegerMathRoundingBenchmark {
  private static final BigInteger[] nonzero1 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] nonzero2 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] positive = new BigInteger[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment

    /**
     * Current position in file
     *
     * @return current position
     */
    long getFilePointer();

    /**
     * Seek to new position
     *
     * @param pos the new position to seek to
     */
    void seek(long pos);

    /**
     * Get the current file length
     *
     * @return file length
     * @throws SmbException if an I/O error occurs