void nullContextThrows() {
            assertThrows(NullPointerException.class, () -> new SmbNamedPipe("smb://server/IPC$/foo", 0, null));
        }

        @Test
        @DisplayName("Second constructor sets unshared based on flags")
        void secondCtorUnsharedFlagPath() throws Exception {
            // Arrange: include UNSHARED flag to exercise that branch

 * #iterator()} method after the first, and whose iterator is always unmodifiable.
 *
 * <p>The {@code Iterable} specification does not make it absolutely clear what should happen on a
 * second invocation, so implementors have made various choices, including:
 *
 * <ul>
 *   <li>returning the same iterator again
 *   <li>throwing an exception of some kind

      sneakyThrow(exception);
    }
  }

  /**
   * Returns a {@link Stream} containing the elements of the first stream, followed by the elements
   * of the second stream, and so on.
   *
   * <p>This is equivalent to {@code Stream.of(streams).flatMap(stream -> stream)}, but the returned
   * stream may perform better.
   *
   * @see Stream#concat(Stream, Stream)
   */

 *     ...
 * }
 * </pre>
 * <p>
 * By default, the {@link Object} class is also included in the iteration. If you do not want to include {@link Object},
 * specify {@literal false} for the second argument of {@link #iterable(Class, boolean)} or {@link #ClassIterator(Class, boolean)}.
 * </p>
 *
 * @author koichik
 */
public class ClassIterator implements Iterator<Class<?>> {

    /** The class */

	t.Skip("long test skip it")

	ctx := t.Context()

	for i := range 10000 {
		nsLk := newNSLock(false)

		// lk1; ref=1
		if !nsLk.lock(ctx, "volume", "path", "source", "opsID", false, time.Second) {
			t.Fatal("failed to acquire lock")
		}

		// lk2
		lk2ch := make(chan struct{})
		go func() {
			defer close(lk2ch)
			nsLk.lock(ctx, "volume", "path", "source", "opsID", false, 1*time.Millisecond)
		}()

ideviceinstaller tools from https://www.libimobiledevice.org/. Use the HEAD versions from
source; the stable versions have bugs that prevents the Go exec wrapper to install and run
apps.

Second, the Go exec wrapper must be told the developer account signing identity, the team
id and a provisioned bundle id to use. They're specified with the environment variables

            throw new SmbException("Buffer access out of bounds");
        }
    }

    /**
     * Safely add integers checking for overflow
     *
     * @param a first value
     * @param b second value
     * @return sum
     * @throws SmbException if overflow would occur
     */
    public int safeAdd(int a, int b) throws SmbException {
        totalValidations.incrementAndGet();

            // First decode
            response.decode(buffer1, 0, 50);
            byte[] data1 = response.getData();

            // Second decode should overwrite
            response.decode(buffer2, 10, 60);
            byte[] data2 = response.getData();

            // Verify second decode overwrote first
            assertEquals(60, data2.length);
            assertEquals((byte) 0x22, data2[0]);
        }
    }

        return Stream.of(Arguments.of(0x1234, 0L, new byte[] { 0x34, 0x12, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                // negative fid wraps around, lastWriteTime = 1000 -> 1 second -> int value 1
                Arguments.of(-1, 1000L, new byte[] { (byte) 0xFF, (byte) 0xFF, 0x01, 0x00, 0x00, 0x00 }));
    }

    /**
     * When lastWriteTime is zero the encoded unsigned time must be all 1s.
     */

func FileWithLineNum() string {
	pcs := [13]uintptr{}
	// the third caller usually from gorm internal
	len := runtime.Callers(3, pcs[:])
	frames := runtime.CallersFrames(pcs[:len])
	for i := 0; i < len; i++ {
		// second return value is "more", not "ok"
		frame, _ := frames.Next()
		if (!strings.HasPrefix(frame.File, gormSourceDir) ||
			strings.HasSuffix(frame.File, "_test.go")) && !strings.HasSuffix(frame.File, ".gen.go") {