* constructor’s flag handling, response creation and simple accessors.
 *
 * <p>All tests run in the same package as the class under test so that
 * package‑private members are visible if required.
 */
@ExtendWith(MockitoExtension.class)
class SmbComNTCreateAndXTest {
    @Mock
    Configuration mockConfig;
    @Mock
    ServerMessageBlock mockAndX;
    @Mock
    CIFSContext mockContext;

      }
    };

    abstract boolean isVisible(int modifiers);

    /** Returns {@code true} if {@code member} is visible under {@code this} visibility. */
    final boolean isVisible(Member member) {
      return isVisible(member.getModifiers());
    }

    final Iterable<Method> getStaticMethods(Class<?> cls) {
      ImmutableList.Builder<Method> builder = ImmutableList.builder();

            // If we got a valid subject, test that it's properly cached and cloned
            Subject cachedOrig = orig.getSubject();
            assertNotNull(cachedOrig);

            // Cached subject is copied and visible via getSubject()
            Subject copySubj = copy.getSubject();
            assertNotNull(copySubj);
            assertSame(cachedOrig, copySubj, "Clone should share the cached Subject reference");

  /*
   * If I understand correctly:
   *
   * This needs to be a @JsMethod so that J2CL knows to look for a JavaScript implemention of
   * it in Platform.native.js. (The JavaScript implementation inline below is visible to *GWT*, but
   * *J2CL* doesn't look at it.)
   *
   * However, once it's a @JsMethod, GWT produces a warning. That's because (a) the *other* purpose

.btn.show {\n  color: var(--bs-btn-active-color);\n  background-color: var(--bs-btn-active-bg);\n  border-color: var(--bs-btn-active-border-color);\n}\n.btn-check:checked + .btn:focus-visible, :not(.btn-check) + .btn:active:focus-visible, .btn:first-child:active:focus-visible, .btn.active:focus-visible, .btn.show:focus-visible {\n  box-shadow: var(--bs-btn-focus-box-shadow);\n}\n.btn:disabled, .btn.disabled, fieldset:disabled .btn {\n  color: var(--bs-btn-disabled-color);\n  pointer-events: none;\n  background-color:...

        return new Impl<>(maxCountLimit, filter);
    }

    /**
     * Creates new instance of problem collector with the specified maximum problem count limit.
     * Visible for testing only.
     *
     * @param <P> the type of problem
     * @param maxCountLimit the maximum number of problems to preserve
     * @return a new problem collector instance
     */
    @Nonnull

     */
    Waiter(boolean unused) {}

    Waiter() {
      // avoid volatile write, write is made visible by subsequent CAS on waitersField field
      putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by a subsequent CAS on
    // waitersField.
    void setNext(@Nullable Waiter next) {
      putNext(this, next);
    }

 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}
 * implementations, synchronization is unnecessary between a thread that writes to one cell and a
 * thread that reads from another.
 *

            containerStyle.height : undefined;

        this.container.setAttribute('data-termynal', '');
        this.container.innerHTML = '';
        for (let line of this.lines) {
            line.style.visibility = 'visible'
        }
        this.start();
    }

    /**
     * Start the animation and rener the lines depending on their data attributes.
     */
    async start() {
        this.addFinish()

     */
    Waiter(boolean unused) {}

    Waiter() {
      // avoid volatile write, write is made visible by subsequent CAS on waitersField field
      putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by a subsequent CAS on
    // waitersField.
    void setNext(@Nullable Waiter next) {
      putNext(this, next);
    }