// 2. the (decrypted) start offset `off` and (decrypted)
	//    length to read `length`
	//
	// These are the inputs to the rest of the algorithm below.

	// Locate the part containing the start of the required range
	var partEnd int
	var cumulativeSum, encCumulativeSum int64
	for i, size := range sizes {
		if off < cumulativeSum+size {
			partStart = i
			break
		}
		cumulativeSum += size

    assertEquals(2, lin.available());
    int read = lin.read();
    assertEquals(big[0], read);
    assertEquals(1, lin.available());
    read = lin.read();
    assertEquals(big[1], read);
    assertEquals(0, lin.available());
    read = lin.read();
    assertEquals(-1, read);

    lin.reset();
    byte[] small = new byte[5];
    read = lin.read(small);
    assertEquals(2, read);
    assertEquals(big[0], small[0]);

            case '<':
                buf.append("&lt;");
                break;
            case '>':
                buf.append("&gt;");
                break;
            case '&':
                buf.append("&amp;");
                break;
            case '"':
                buf.append("&quot;");
                break;
            default:
                buf.append(element);
            }

		if !isErrReadQuorum(err) {
			t.Errorf("Expected read quorum error when if-match is used with quorum failure, got: %v", err)
		}
	})

	t.Run("if-match wrong etag with read quorum failure", func(t *testing.T) {
		// Test Case 3: if-match with wrong ETag
		// Even if the ETag doesn't match, we should still get read quorum error
		// because we can't read the object to check the condition.
		opts := ObjectOptions{

    /**
     * Read and Write caching (RW)
     */
    public static final int SMB2_LEASE_READ_WRITE = 0x05;

    /**
     * Full caching - Read, Write and Handle (RWH)
     */
    public static final int SMB2_LEASE_FULL = 0x07;

    private Smb2LeaseState() {
        // Utility class
    }

    /**
     * Check if state has read caching
     * @param state lease state

                if (reactorContext.getReactorBuildStatus().isHalted()) {
                    break;
                }
            } catch (Exception e) {
                session.getResult().addException(e);
                break;
            }
        }

        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
    }

            break;
        case "errors.password_no_special_char":
            messages.addErrorsPasswordNoSpecialChar(GLOBAL);
            break;
        case "errors.password_is_blacklisted":
            messages.addErrorsPasswordIsBlacklisted(GLOBAL);
            break;
        default:
            messages.addErrorsBlankPassword(GLOBAL);
            break;
        }
    }

    /**

          val byte1 = this[mid + publicSuffixByteIndex] and 0xff

          compareResult = byte0 - byte1
          if (compareResult != 0) break

          publicSuffixByteIndex++
          currentLabelByteIndex++
          if (publicSuffixByteIndex == publicSuffixLength) break

          if (labels[currentLabelIndex].size == currentLabelByteIndex) {

    assertEquals(0, ticker.read());
    assertEquals(10, ticker.read());
    assertEquals(20, ticker.read());
  }

  public void testAutoIncrementStep_millis() {
    FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, MILLISECONDS);
    assertEquals(0, ticker.read());
    assertEquals(1000000, ticker.read());
    assertEquals(2000000, ticker.read());
  }

import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Read AndX Response message.
 *
 * This response contains the data that was read from the file
 * along with information about the read operation.
 */
public class SmbComReadAndXResponse extends AndXServerMessageBlock {

    private byte[] data;
    private int offset, dataCompactionMode, dataLength, dataOffset;

    /**
     * Constructs a Read AndX response.
     *