if err == nil {
		return nil
	}
	r := RemoteErr(err.Error())
	return &r
}

// NewRemoteErrf creates a new remote error from a format string.
func NewRemoteErrf(format string, a ...any) *RemoteErr {
	r := RemoteErr(fmt.Sprintf(format, a...))
	return &r
}

// NewNPErr is a helper to no payload and optional remote error.
// The error type is not preserved.

        assertEquals(8, bytesRead);
        assertTrue(fileInfo.toString().contains("endOfFile=" + value));
    }

    @Test
    @DisplayName("Test toString format")
    void testToString() {
        // Test default constructor
        String str1 = fileInfo.toString();
        assertNotNull(str1);
        assertTrue(str1.startsWith("EndOfFileInformation["));

mvn test                                 # Run all tests
mvn test -Dtest=SuggesterTest           # Run specific test
mvn package                              # Package JAR
mvn formatter:format license:format     # Format code and apply licenses
mvn clean jacoco:prepare-agent test jacoco:report  # Generate coverage report
```

### Adding New Features

1. Read related source files and tests

      if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
        i.set(newEntry);
        return;
      }
    }

    throw new IllegalArgumentException(
        Platform.format("key %s not found in entries %s", newEntry.getKey(), expected));
  }

  /**
   * Wrapper for {@link Map#get(Object)} that forces the caller to pass in a key of the same type as

            project.dependencies.addProvider(
                annotationProcessorConfigurationName,
                extension.enabled.filter { it }.map { dep }
            )
        }

        // don't forget to update the version in distributions-dependencies/build.gradle.kts
        addErrorProneDependency("com.google.errorprone:error_prone_core:2.42.0")
        addErrorProneDependency("com.uber.nullaway:nullaway:0.12.10")

 */
package org.codelibs.fess.suggest;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.stream.Stream;

import org.apache.logging.log4j.LogManager;

///

## OAuth2-Scopes und OpenAPI { #oauth2-scopes-and-openapi }

Die OAuth2-Spezifikation definiert „Scopes“ als eine Liste von durch Leerzeichen getrennten Strings.

Der Inhalt jedes dieser Strings kann ein beliebiges Format haben, sollte jedoch keine Leerzeichen enthalten.

Diese Scopes stellen „Berechtigungen“ dar.

In OpenAPI (z. B. der API-Dokumentation) können Sie „Sicherheitsschemas“ definieren.

                    } else {
                        out.print("&nbsp;</div>");
                    }
                    out.print("<div style='width: 180'>");
                    out.print(sdf.format(new Date(f.lastModified())));
                    out.print("</div>");
                }
                out.println("<br clear='all'>");
            } else {
                out.print("<A style=\"width: " + maxLen);

import java.io.Closeable
import java.io.EOFException
import java.io.IOException
import java.util.logging.Level.FINE
import java.util.logging.Logger
import okhttp3.internal.and
import okhttp3.internal.format
import okhttp3.internal.http2.Http2.CONNECTION_PREFACE
import okhttp3.internal.http2.Http2.FLAG_ACK
import okhttp3.internal.http2.Http2.FLAG_COMPRESSED
import okhttp3.internal.http2.Http2.FLAG_END_HEADERS

     * @throws SmbException if the textual format is invalid
     */
    public SID(final String textual) throws SmbException {
        final StringTokenizer st = new StringTokenizer(textual, "-");
        if (st.countTokens() < 3 || !st.nextToken().equals("S")) {
            // need S-N-M
            throw new SmbException("Bad textual SID format: " + textual);
        }