macros          map[string]*Macro
	text            string // Text of last token returned by Next.
	peek            bool
	peekToken       ScanToken
	peekText        string
}

// NewInput returns an Input from the given path.
func NewInput(name string) *Input {
	return &Input{
		// include directories: look in source dir, then -I directories.
		includes:        append([]string{filepath.Dir(name)}, flags.I...),
		beginningOfLine: true,

    private final ConcurrentHashMap<String, MockRegistration> registrations = new ConcurrentHashMap<>();
    private Thread serverThread;

    /**
     * Mock registration data
     */
    private static class MockRegistration {
        final String registrationId;
        final String shareName;
        final String serverAddress;
        final int flags;
        final long timestamp;

          <version>1.0.0+</version>
          <description>Name of the plugin.</description>
          <type>String</type>
        </field>
        <field>
          <name>description</name>
          <version>1.0.0+</version>
          <description>Description of the plugin.</description>
          <type>String</type>
        </field>
        <field>
          <name>groupId</name>
          <version>1.0.0+</version>

                { "\\pipe\\samr", "samr", "12345778-1234-ABCD-EF00-0123456789AC", 1, 0 } };

        for (Object[] data : testData) {
            String endpoint = (String) data[0];
            String pipeName = (String) data[1];
            String expectedUuid = (String) data[2];
            int expectedMajor = (int) data[3];
            int expectedMinor = (int) data[4];

            // The interfaces are added in setUp()

  public static class ImmutableListMultimapGenerator extends TestStringListMultimapGenerator {
    @Override
    protected ListMultimap<String, String> create(Entry<String, String>[] entries) {
      ImmutableListMultimap.Builder<String, String> builder = ImmutableListMultimap.builder();
      for (Entry<String, String> entry : entries) {
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

    private final SuggestSettings settings;

    /** Analyzer map. */
    protected static Map<String, Set<String>> analyzerMap = new ConcurrentHashMap<>();
    /** Field analyzer mapping map. */
    protected static Map<String, Map<String, FieldAnalyzerMapping>> fieldAnalyzerMappingMap = new ConcurrentHashMap<>();

    /** Supported languages. */

    private final String name;

    public StringSubscriber(String name) {
      this.name = name;
    }

    @Subscribe
    public void handleString(String string) {
      dispatchedSubscribers.add(this);
    }

    @Override
    public String toString() {
      return name;
    }
  }

     * @return a SuggestItem created from the given search words and associated data
     */
    SuggestItem parseSearchWords(String[] words, String[][] readings, String[] fields, String[] tags, String[] roles, long score,
            ReadingConverter readingConverter, Normalizer normalizer, SuggestAnalyzer analyzer, String[] langs);

    /**
     * Parses the given query log and returns a list of suggest items.
     *

    public void setVersion(String version) {
        artifact.setVersion(version);
    }

    /** {@inheritDoc} */
    @Override
    public String getScope() {
        return artifact.getScope();
    }

    /** {@inheritDoc} */
    @Override
    public String getType() {
        return artifact.getType();
    }

    /** {@inheritDoc} */
    @Override
    public String getClassifier() {

        String decodedName = new String(nameBytes, StandardCharsets.UTF_16LE);
        assertEquals(fileName, decodedName);

        // Verify bytes written
        assertEquals(20 + nameLength, bytesWritten);
    }

    @Test
    @DisplayName("Test encode with replaceIfExists false")
    void testEncodeWithReplaceIfExistsFalse() {
        String fileName = "newfile.txt";