}

    @Override
    public int size() {
      return obverse.size;
    }

    @Override
    public void clear() {
      obverse.clear();
    }

    @Override
    public boolean containsKey(@Nullable Object key) {
      Object obverseValue = key;
      return obverse.containsValue(obverseValue);
    }

    @Override
    public @Nullable K get(@Nullable Object key) {

        int attributes;

        @Override
        public int getAttributes() {
            return attributes;
        }

        @Override
        public long getCreateTime() {
            return createTime;
        }

        @Override
        public long getLastWriteTime() {
            return lastWriteTime;
        }

        @Override
        public long getSize() {
            return 0L;
        }

              }
            });
  }

  public void testCreate_invalidType() {
    assertThrows(IllegalArgumentException.class, () -> MediaType.create("te><t", "plaintext"));
  }

  public void testCreate_invalidSubtype() {
    assertThrows(IllegalArgumentException.class, () -> MediaType.create("text", "pl@intext"));
  }

  public void testCreate_wildcardTypeDeclaredSubtype() {

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.dcerpc.ndr;

/**
 * NDR representation of a hyper integer (8-byte signed integer).
 */
public class NdrHyper extends NdrObject {

    /**
     * The hyper integer value.
     */
    public long value;

    /**

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.dcerpc.ndr;

/**
 * NDR representation of a long integer (4-byte signed integer).
 */
public class NdrLong extends NdrObject {

    /**
     * The long integer value.
     */
    public int value;

    /**

      return current;
    }

    @Override
    public int nextIndex() {
      return nextIndex;
    }

    @Override
    public int previousIndex() {
      return nextIndex - 1;
    }

    @Override
    public void set(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void add(Entry<K, V> e) {

/**
 * Test class for PersistentHandleManager functionality
 */
public class PersistentHandleManagerTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private jcifs.Configuration mockConfig;

    private PersistentHandleManager manager;
    private Path tempDir;

    @BeforeEach
    public void setUp() throws IOException {
        MockitoAnnotations.openMocks(this);

   * method is called reflectively by Subscriber during tests, and must remain public.
   *
   * @param arg argument to record.
   */
  @Subscribe
  public void recordingMethod(Object arg) {
    assertFalse(methodCalled);
    methodCalled = true;
    methodArgument = arg;
  }

  @Subscribe
  public void exceptionThrowingMethod(Object arg) throws Exception {
    throw new IntentionalException();

 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *

    }
  }

  @Override
  public void write(byte[] b) throws IOException {
    write(b, 0, b.length);
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    try {
      state.write(b, off, len);
    } finally {
      reachabilityFence(byteSource);
    }
  }

  @Override
  public void close() throws IOException {
    try {
      state.close();
    } finally {