private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
  private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
      ImmutableMap.of(
          '\n', "<newline>",
          '\t', "<tab>",
          '&', "<and>");

  public void testSafeRange() throws IOException {
    // Basic escaping of unsafe chars (wrap them in {,}'s)
    CharEscaper wrappingEscaper =

     * Gets the original input words.
     *
     * @return The original input words.
     */
    public String[] getInputs() {
        return inputs;
    }

    /**
     * Gets the input words as a newline-separated string.
     *
     * @return The input words as a string.
     */
    public String getInputsValue() {
        if (inputs == null) {
            return StringUtil.EMPTY;
        }

}

func NewTokenizer(name string, r io.Reader, file *os.File) *Tokenizer {
	var s scanner.Scanner
	s.Init(r)
	// Newline is like a semicolon; other space characters are fine.
	s.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
	// Don't skip comments: we need to count newlines.
	s.Mode = scanner.ScanChars |
		scanner.ScanFloats |
		scanner.ScanIdents |
		scanner.ScanInts |
		scanner.ScanStrings |

	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

// genLine writes to buf a predictable but non-trivial line of text of length
// n, including the terminal newline and an occasional carriage return.
// If addNewline is false, the \r and \n are not emitted.
func genLine(buf *bytes.Buffer, lineNum, n int, addNewline bool) {
	buf.Reset()
	doCR := lineNum%5 == 0
	if doCR {
		n--

    @Nonnull
    default MessageBuilder a(Object value) {
        return append(String.valueOf(value));
    }

    /**
     * Append newline to the message buffer.
     *
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder newline() {
        return append(System.lineSeparator());
    }

    /**
     * Append formatted content to the buffer.

  while (!exhausted()) {
    if (buffer[0] != ' '.code.toByte()) return
    skip(1L)
  }
}

private fun BufferedSource.skipRestOfLine() {
  when (val newline = indexOf('\n'.code.toByte())) {
    -1L -> skip(buffer.size) // Exhaust this source.
    else -> skip(newline + 1)
  }
}

/**
 * Reads lines from `IdnaMappingTable.txt`.
 *

        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> "test \"quotes\" and \n newline";

        monitorTarget.append(buf, "specialKey", supplier);
        assertEquals("\"specialKey\":\"test \\\"quotes\\\" and \\n newline\"", buf.toString());
    }

    // Test append method with String containing backslash
    public void test_append_stringWithBackslash() {

        text: 'dot-imports:'
      - path: (.+)\.go$
        text: should have a package comment
      - path: (.+)\.go$
        text: error strings should not be capitalized or end with punctuation or a newline
    paths:
      - third_party$
      - builtin$
      - examples$
issues:
  max-issues-per-linter: 100
  max-same-issues: 100
formatters:
  enable:
    - gofumpt
    - goimports
  exclusions:

        assertEquals(message, exception.getMessage());
    }

    public void test_newlineCharactersInMessage() {
        // Test with newline characters in message
        String message = "LDAP error:\n- Connection failed\n- Invalid credentials\n- Timeout";
        LdapConfigurationException exception = new LdapConfigurationException(message);

        assertSame(inputs, item.getNewInputs());
        assertEquals("result", item.getNewOutput());
    }

    public void test_constructor_withNewlineInOutput() {
        // Test newline replacement in output
        String[] inputs = { "input" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "line1\nline2");

        assertEquals("line1 line2", item.getOutput());
    }