public void testNoSuchElement() {
        exception.expect(NoSuchElementException.class);
        exception.expectMessage(is("index=2"));
        final ArrayIterator<Integer> itr = new ArrayIterator<Integer>(new Integer[] { 1, 2 });
        itr.next();
        itr.next();
        itr.next();
    }

    /**
     *
     */
    @Test
    public void testHasNext() {

    @Test
    public void testReadParameterWordsUpdatesCount() {
        // create a buffer with count = 0x1234 (4660 decimal)
        // Using little-endian byte order as per SMBUtil.readInt2
        byte[] buf = new byte[12];
        buf[0] = 0x34; // Low byte
        buf[1] = 0x12; // High byte
        int written = resp.readParameterWordsWireFormat(buf, 0);

                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <div class="row">
                <div class="col-md-12">
                    <div class="card card-outline card-primary">
                        <div class="card-header">
                            <h3 class="card-title">

            byte[] src = new byte[] { 0, 1, 2, 3 };
            return Stream.of(Arguments.of(src, 0, 0, new byte[] {}), Arguments.of(src, 0, 4, new byte[] { 0, 1, 2, 3 }),
                    Arguments.of(src, 1, 2, new byte[] { 1, 2 }), Arguments.of(src, 3, 1, new byte[] { 3 }));
        }

        @ParameterizedTest(name = "slice off={1}, len={2}")
        @MethodSource("validRanges")

    assertThat(set.headSet(3)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(4)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(Integer.MAX_VALUE)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(1, true)).containsExactly(1).inOrder();
    assertThat(set.headSet(2, true)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(3, true)).containsExactly(1, 2, 3).inOrder();

            // Use the nonce directly if it's 12 bytes (generated appropriately)
            final byte[] adjustedNonce;
            if (nonce.length == 12) {
                adjustedNonce = nonce;
            } else {
                // Fallback for compatibility
                adjustedNonce = new byte[12];
                System.arraycopy(nonce, 0, adjustedNonce, 0, Math.min(12, nonce.length));
            }

                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <div class="row">
                <div class="col-md-12">
                    <div class="card card-outline card-primary">
                        <div class="card-header">
                            <jsp:include page="/WEB-INF/view/common/admin/crud/header.jsp"></jsp:include>

                        </ol>
                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <div class="row">
                <div class="col-md-12">
                    <div class="card card-outline card-primary">
                        <div class="card-header">
                            <h3 class="card-title">

	// logical instructions
	// shift instructions
	// unary instructions
	//
	//	LADDW rreg ',' sreg ',' rreg
	//	{
	//		outcode(int($1), &$2, int($4), &$6);
	//	}
	ADD	R1, R2, R3

	//	LADDW imm ',' sreg ',' rreg
	//	{
	//		outcode(int($1), &$2, int($4), &$6);
	//	}
	ADD	$1, R2, R3

	//	LADDW rreg ',' rreg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	ADD	R1, R2

    Comparator<Optional<String>> unused = emptiesLast(naturalOrder());
  }

  public void testMinMaxNatural() {
    assertThat(min(1, 2)).isEqualTo(1);
    assertThat(min(2, 1)).isEqualTo(1);
    assertThat(max(1, 2)).isEqualTo(2);
    assertThat(max(2, 1)).isEqualTo(2);
  }

  public void testMinMaxNatural_equalInstances() {
    Foo a = new Foo(1);
    Foo b = new Foo(1);