// Test with a very long component name
        String longName = "com.example.very.long.package.name.with.many.nested.levels.MyVeryLongComponentNameThatExceedsNormalLength";
        ContainerNotAvailableException exception = new ContainerNotAvailableException(longName, null);

        assertEquals(longName + " is not available.", exception.getMessage());
        assertEquals(longName, exception.getComponentName());
    }

    @Test

        String[] values = { longValue };
        RequestParameter param = new RequestParameter(longName, values);

        assertEquals(longName, param.getName());
        assertNotNull(param.getValues());
        assertEquals(1, param.getValues().length);
        assertEquals(longValue, param.getValues()[0]);
    }

    @Test
    public void test_getName() {
        // Test getName method explicitly

				Typeflag: TypeReg,
				Name:     strings.Repeat("longname/", 15) + "16gig.txt",
				Size:     16 << 30,
				Mode:     0644,
				Uid:      1000,
				Gid:      1000,
				Uname:    "guillaume",
				Gname:    "guillaume",
				ModTime:  time.Unix(1399583047, 0),
			}, nil},
		},
	}, {
		// This file was produced using GNU tar v1.17.
		//	gnutar -b 4 --format=ustar (longname/)*15 + file.txt
		file: "testdata/ustar.tar",

    public void test_provide_withLongClassificationName() {
        // Test with very long classification name
        StringBuilder longName = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            longName.append("VeryLongClassificationName");
        }
        assertProvideThrowsException(longName.toString());
    }

    @Test
    public void test_provide_withUnicodeCharacters() {

    @Test
    public void test_buildFilePath_longPathComponent() {
        final StringBuilder longName = new StringBuilder();
        for (int i = 0; i < 250; i++) {
            longName.append("a");
        }
        final Path result =
                indexExportJob.buildFilePath("/export", "https://example.com/" + longName + ".html", new HtmlIndexExportFormatter());
        final String fileName = result.getFileName().toString();

    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }

    private boolean isFirstPublicClassInHierarchy(CtMethod method, CtClass c) {
        List<CtClass> classesContainingMethod = []

        CtClass current = c
        while (current != null) {

    return policy == Policies.DISABLED
        ? new ReentrantLock(fair)
        : new CycleDetectingReentrantLock(new LockGraphNode(lockName), fair);
  }

  /** Equivalent to {@code newReentrantReadWriteLock(lockName, false)}. */
  public ReentrantReadWriteLock newReentrantReadWriteLock(String lockName) {
    return newReentrantReadWriteLock(lockName, false);
  }

  /**

			ModTime:  time.Unix(1392395740, 0),
			Typeflag: 0x53,
			Linkname: "",
			Uname:    "david",
			Gname:    "david",
			Devmajor: 0,
			Devminor: 0,
			Format:   FormatGNU,
		}, {
			Name:     "sparse-posix-0.0",
			Mode:     420,
			Uid:      1000,
			Gid:      1000,
			Size:     200,
			ModTime:  time.Unix(1392342187, 0),
			Typeflag: 0x30,
			Linkname: "",
			Uname:    "david",
			Gname:    "david",

Der Exit-Code, das automatische Schließen der `Session` in:

{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}

... würde ausgeführt, nachdem die Response das langsame Senden der Daten beendet:

{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}

// It is analogous to the facilities of the [strings] package.
package bytes

import (
	"internal/bytealg"
	"math/bits"
	"unicode"
	"unicode/utf8"
	_ "unsafe" // for linkname
)

// Equal reports whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []byte) bool {