import java.util.Iterator;
import java.util.NoSuchElementException;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * An {@link Iterator} that iterates over multiple {@link Iterator}s as if they were a single {@link Iterator}.
 * <p>
 * Usage example:
 * </p>
 *
 * <pre>
 * import static org.codelibs.core.collection.MultiIterator.*;
 *
 * List&lt;String&gt; list = ...;
 * Set&lt;String&gt; set = ...;

description: File a bug report
labels: ["bug"]

body:
  - type: markdown
    attributes:
      value: |
        Thanks for taking the time to fill out this bug report.     

        Simple fixes in single PRs do not require issues. 
  
        **Do you use the latest project version?**

  - type: input
    id: version
    attributes:
      label: Affected version
    validations:
      required: true

	return t&other == other
}

// Overlaps returns whether *any* flags in t overlaps with other.
func (t Mask) Overlaps(other Mask) bool {
	return t&other != 0
}

// SingleType returns whether t has a single type set.
func (t Mask) SingleType() bool {
	return bits.OnesCount64(uint64(t)) == 1
}

// FromUint64 will set a mask to the uint64 value.
func (t *Mask) FromUint64(m uint64) {
	*t = Mask(m)
}

 */

package jcifs.smb1.dcerpc.ndr;

/**
 * Represents an NDR small integer (1 byte unsigned) for DCE/RPC communication.
 * This class encapsulates a single byte value (0-255) in NDR format.
 */
public class NdrSmall extends NdrObject {

    /**
     * The small integer value (0-255)
     */
    public int value;

    /**

import org.junit.jupiter.params.provider.ValueSource;

/**
 * Test class for StringUtil utility methods
 */
class StringUtilTest {

    @Test
    @DisplayName("Should join single element without delimiter")
    void testJoinSingleElement() {
        String result = StringUtil.join(",", "hello");
        assertEquals("hello", result);
    }

    @Test

import org.jspecify.annotations.Nullable;

/**
 * Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
 * a <i>separator</i> sequence. This separator can be specified as a single {@linkplain #on(char)
 * character}, fixed {@linkplain #on(String) string}, {@linkplain #onPattern regular expression} or
 * {@link #on(CharMatcher) CharMatcher} instance. Or, instead of using a separator at all, a

  /**
   * Indicates that the constructor or factory method of a collection, usually an immutable set,
   * throws an {@link IllegalArgumentException} when presented with duplicate elements instead of
   * collapsing them to a single element or including duplicate instances in the collection.
   */
  REJECTS_DUPLICATES_AT_CREATION,

  SUPPORTS_ADD,
  SUPPORTS_REMOVE,
  SUPPORTS_ITERATOR_REMOVE,
  FAILS_FAST_ON_CONCURRENT_MODIFICATION,

under the License.
-->

<!--
 | This is the toolchains file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This toolchains.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/toolchains.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -t /path/to/user/toolchains.xml

   */
  @SuppressWarnings("unchecked")
  public static <K extends Comparable<?>, V> ImmutableRangeMap<K, V> of() {
    return (ImmutableRangeMap<K, V>) EMPTY;
  }

  /** Returns an immutable range map mapping a single range to a single value. */
  public static <K extends Comparable<?>, V> ImmutableRangeMap<K, V> of(Range<K> range, V value) {
    return new ImmutableRangeMap<>(ImmutableList.of(range), ImmutableList.of(value));
  }

   * operation takes amortized linear time in the length of {@code elements}.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterable}, prefer
   * {@link Ordering#leastOf(Iterable, int)}, which provides a simpler API for that use case.
   */
  public void offerAll(Iterable<? extends T> elements) {
    offerAll(elements.iterator());
  }