sf.line, sf.col = val.Line, val.Column
	return nil
}

// InRange returns true in the following cases and false otherwise,
// - sf.LowerBound < sz, when sf.LowerBound alone is specified
// - sz < sf.UpperBound, when sf.UpperBound alone is specified
// - sf.LowerBound < sz < sf.UpperBound when both are specified,
func (sf BatchJobSizeFilter) InRange(sz int64) bool {
	if sf.UpperBound > 0 && sz > int64(sf.UpperBound) {

    OPS_5("+-*/%"),
    HEX_16(CharMatcher.inRange('0', '9').or(CharMatcher.inRange('A', 'F')), "0123456789ABCDEF"),
    HEX_22(
        CharMatcher.inRange('0', '9')
            .or(CharMatcher.inRange('A', 'F'))
            .or(CharMatcher.inRange('a', 'f')),
        "0123456789ABCDEFabcdef"),
    GERMAN_59(
        CharMatcher.inRange('a', 'z')
            .or(CharMatcher.inRange('A', 'Z'))
            .or(CharMatcher.anyOf("äöüßÄÖÜ")),

  LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override
    String normalizeWord(String word) {
      return firstCharOnlyToUpper(word);
    }

    @Override
    String normalizeFirstWord(String word) {
      return Ascii.toLowerCase(word);
    }
  },

  /** Java and C++ class naming convention, e.g., "UpperCamel". */
  UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override

  LOWER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override
    String normalizeWord(String word) {
      return firstCharOnlyToUpper(word);
    }

    @Override
    String normalizeFirstWord(String word) {
      return Ascii.toLowerCase(word);
    }
  },

  /** Java and C++ class naming convention, e.g., "UpperCamel". */
  UPPER_CAMEL(CharMatcher.inRange('A', 'Z'), "") {
    @Override

		},
		{
			// 11MiB > 10 MiB -> out of range from right
			objSize: 11 << 20,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,
				LowerBound: 1 << 20,
			},
			want: false,
		},
		{
			//  2MiB < 10MiB -> in range
			objSize: 2 << 20,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,
			},
			want: true,
		},
		{
			//  2MiB > 1MiB -> in range
			objSize: 2 << 20,

func parseCopyPartRangeSpec(rangeString string) (hrange *HTTPRangeSpec, err error) {
	hrange, err = parseRequestRangeSpec(rangeString)
	if err != nil {
		return nil, err
	}
	if hrange.IsSuffixLength || hrange.Start < 0 || hrange.End < 0 {
		return nil, errInvalidRange
	}
	return hrange, nil
}

// checkCopyPartRangeWithSize adds more check to the range string in case of

        return true;
    }

    private static boolean isInRange(String value, List<RangeValue> range) {
        int leftRelation = getRelationOrder(value, range.get(0), true);

        if (leftRelation == 0) {
            return true;
        }

        if (leftRelation < 0) {
            return false;
        }

        return getRelationOrder(value, range.get(1), false) <= 0;
    }

            // Arrange
            Smb2LogoffRequest req = newRequest();

            // Act/Assert
            assertThrows(NullPointerException.class, () -> req.createResponse(null, req));
        }

        @Test
        @DisplayName("createResponse tolerates null request parameter")
        void createResponse_nullRequest_ok() {
            // Arrange

        return new Smb2LogoffResponse(cfg);
    }

    @Test
    @DisplayName("Constructor accepts a Configuration and creates instance")
    void constructor_happyPath() {
        // Arrange
        Configuration cfg = Mockito.mock(Configuration.class);

        // Act
        Smb2LogoffResponse resp = new Smb2LogoffResponse(cfg);

        // Assert

    }

    @Test
    @DisplayName("accept: returns true for directories; verifies isDirectory is invoked")
    void accept_returnsTrueForDirectory_andVerifiesInteraction() throws Exception {
        // Arrange: filter that accepts directories only
        SmbFileFilter filter = f -> f.isDirectory();
        when(smbFile.isDirectory()).thenReturn(true);

        // Act
        boolean result = filter.accept(smbFile);