// my best guess is that the jdk authors have spent more time optimizing that callpath than this
    // one. (StringCoding$StringDecoder vs. StreamDecoder).  StringCoding has a ton of special cases
    // theoretically we could duplicate all that logic here to try to beat 'new String' or at least
    // come close.
    USING_DECODER_WITH_SIZE_HINT {
      @Override

 *   <li>{@link StandardSystemProperty}
 *   <li>{@link Stopwatch}
 *   <li>{@link Throwables}
 *   <li>{@link Verify}
 * </ul>
 *
 * <h3>The rest</h3>
 *
 * This package also contains some classes with niche use cases (e.g., {@link Utf8} and {@link
 * Defaults}), as well as a number of classes that have been superseded by additions to the JDK.
 */
@CheckReturnValue
@NullMarked
package com.google.common.base;

import com.google.common.eventbus.Subscribe;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import junit.framework.TestCase;

/**
 * Test cases for {@code EventBus} that must not be in the same package.
 *
 * @author Louis Wasserman
 */
public class OutsideEventBusTest extends TestCase {

  /*

            switch (tagged.getTagNo()) {
            case 0:
                ASN1Integer pvno = ASN1Util.as(ASN1Integer.class, tagged);
                if (!pvno.getValue().equals(new BigInteger(KerberosConstants.KERBEROS_VERSION))) {
                    throw new PACDecodingException("Invalid kerberos version");
                }
                break;
            case 1:

 * {@link SmbException#getStatusByCode(int)}.
 */
@DisplayName("SmbAuthException Tests")
class SmbAuthExceptionTest {

    /**
     * Provides a set of error codes covering normal, edge and unknown cases.
     */
    static Stream<Arguments> errorCodes() {
        return Stream.of(
                // Known NT status code - NT_STATUS_UNSUCCESSFUL

	var listSTSKeys, listServiceAccounts bool
	switch listType {
	case madmin.AccessKeyListUsersOnly:
		listSTSKeys = false
		listServiceAccounts = false
	case madmin.AccessKeyListSTSOnly:
		listSTSKeys = true
		listServiceAccounts = false
	case madmin.AccessKeyListSvcaccOnly:
		listSTSKeys = false
		listServiceAccounts = true
	case madmin.AccessKeyListAll:
		listSTSKeys = true
		listServiceAccounts = true

class Trans2FindFirst2ResponseTest {

    private Trans2FindFirst2Response response;

    @BeforeEach
    void setUp() {
        response = new Trans2FindFirst2Response();
    }

    // Test cases for SmbFindFileBothDirectoryInfo inner class
    @Test
    void testSmbFindFileBothDirectoryInfo_Getters() {
        Trans2FindFirst2Response.SmbFindFileBothDirectoryInfo info = response.new SmbFindFileBothDirectoryInfo();

	switch GOARCH {
	case "386":
		return archX86(&x86.Link386)
	case "amd64":
		return archX86(&x86.Linkamd64)
	case "arm":
		return archArm()
	case "arm64":
		return archArm64()
	case "loong64":
		return archLoong64(&loong64.Linkloong64)
	case "mips":
		return archMips(&mips.Linkmips)
	case "mipsle":
		return archMips(&mips.Linkmipsle)
	case "mips64":
		return archMips64(&mips.Linkmips64)

type EncryptedString string

func (es *EncryptedString) Scan(ctx context.Context, field *schema.Field, dst reflect.Value, dbValue interface{}) (err error) {
	switch value := dbValue.(type) {
	case []byte:
		*es = EncryptedString(bytes.TrimPrefix(value, []byte("hello")))
	case string:
		*es = EncryptedString(strings.TrimPrefix(value, "hello"))
	default:
		return fmt.Errorf("unsupported data %#v", dbValue)
	}
	return nil
}

		skip, record bool
	)

	for s.Scan() {
		line := s.Text()
		switch {
		case skip && line != "":
		case skip && line == "":
			skip = false
		case record && line == "":
			stackTrace := bf.String()
			reset()
			record = false
			if searchRE == nil || searchRE.MatchString(stackTrace) {
				ret[t] = append(ret[t], stackTrace)
			}
		case record:
			save(line)
		default:
			z := goroutinesRE.FindStringSubmatch(line)