samr.SamrSamEntry entry = new samr.SamrSamEntry();
            when(mockNdrBuffer.dec_ndr_long()).thenReturn(1, 0); // idx, _name_bufferp = 0
            when(mockNdrBuffer.dec_ndr_short()).thenReturn(0, 0); // length, maximum_length

            // When: Decoding entry
            entry.decode(mockNdrBuffer);

            // Then: Should have null buffer
            assertEquals(1, entry.idx);

    public void testCompressionRatioEstimation() {
        double ratio = compressionService.estimateCompressionRatio(testData, CompressionService.COMPRESSION_LZ77);
        assertTrue(ratio >= 0.0 && ratio <= 1.0);

        double noneRatio = compressionService.estimateCompressionRatio(testData, CompressionService.COMPRESSION_NONE);
        assertEquals(1.0, noneRatio, 0.001);
    }

    @Test

// The remaining payload and versions are returned.
func checkXL2V1(buf []byte) (payload []byte, major, minor uint16, err error) {
	if len(buf) <= 8 {
		return payload, 0, 0, fmt.Errorf("xlMeta: no data")
	}

	if !bytes.Equal(buf[:4], xlHeader[:]) {
		return payload, 0, 0, fmt.Errorf("xlMeta: unknown XLv2 header, expected %v, got %v", xlHeader[:4], buf[:4])
	}

	if bytes.Equal(buf[4:8], []byte("1   ")) {
		// Set as 1,0.

*/
package builtin

import "cmp"

// bool is the set of boolean values, true and false.
type bool bool

// true and false are the two untyped boolean values.
const (
	true  = 0 == 0 // Untyped bool.
	false = 0 != 0 // Untyped bool.
)

// uint8 is the set of all unsigned 8-bit integers.
// Range: 0 through 255.
type uint8 uint8

// uint16 is the set of all unsigned 16-bit integers.
// Range: 0 through 65535.

        assertEquals(0, response.writeParametersWireFormat(dst, 0));
        assertEquals(0, response.writeDataWireFormat(dst, 0));
        assertEquals(0, response.readSetupWireFormat(dst, 0, 0));
    }

    @Test
    void testToString_FindFirst2() {
        response.subCommand = SmbComTransaction.TRANS2_FIND_FIRST2;
        response.sid = 123;
        response.numEntries = 5;

    input = Arrays.copyOf(input, input.length);
    Floats.reverse(input, fromIndex, toIndex);
    assertThat(input).isEqualTo(expectedOutput);
  }

  public void testReverseIndexed() {
    testReverse(new float[] {}, 0, 0, new float[] {});
    testReverse(new float[] {1}, 0, 1, new float[] {1});
    testReverse(new float[] {1, 2}, 0, 2, new float[] {2, 1});
    testReverse(new float[] {3, 1, 1}, 0, 2, new float[] {1, 3, 1});

    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicInstanceMethods(Ints.stringConverter());
  }

  public void testTryParse() {
    tryParseAndAssertEquals(0, "0");
    tryParseAndAssertEquals(0, "-0");
    tryParseAndAssertEquals(1, "1");
    tryParseAndAssertEquals(-1, "-1");
    tryParseAndAssertEquals(8900, "8900");
    tryParseAndAssertEquals(-8900, "-8900");

    input = Arrays.copyOf(input, input.length);
    Floats.reverse(input, fromIndex, toIndex);
    assertThat(input).isEqualTo(expectedOutput);
  }

  public void testReverseIndexed() {
    testReverse(new float[] {}, 0, 0, new float[] {});
    testReverse(new float[] {1}, 0, 1, new float[] {1});
    testReverse(new float[] {1, 2}, 0, 2, new float[] {2, 1});
    testReverse(new float[] {3, 1, 1}, 0, 2, new float[] {1, 3, 1});

    SignedBytes.sortDescending(input, fromIndex, toIndex);
    assertThat(input).isEqualTo(expectedOutput);
  }

  public void testSortDescendingIndexed() {
    testSortDescending(new byte[] {}, 0, 0, new byte[] {});
    testSortDescending(new byte[] {1}, 0, 1, new byte[] {1});
    testSortDescending(new byte[] {1, 2}, 0, 2, new byte[] {2, 1});
    testSortDescending(new byte[] {1, 3, 1}, 0, 2, new byte[] {3, 1, 1});

      super("b", "a", "c", "d", "e");
    }

    // for testing SortedSet and SortedMap methods
    public static final String BEFORE_FIRST = "\0";
    public static final String BEFORE_FIRST_2 = "\0\0";
    public static final String MIN_ELEMENT = "a";
    public static final String AFTER_LAST = "z";
    public static final String AFTER_LAST_2 = "zz";
  }

  public static class Chars extends SampleElements<Character> {