@Test
  public void basicWriteAndReadTest() throws IOException, StoreException {
    LogSegmentName segmentName = LogSegmentName.generateFirstSegmentName(false);
    LogSegment segment = getSegment(segmentName, STANDARD_SEGMENT_SIZE, true);
    segment.initBufferForAppend();
    try {
      assertEquals("Name of segment is inconsistent with what was provided", segmentName, segment.getName());
      assertEquals("Capacity of segment is inconsistent with what was provided", STANDARD_SEGMENT_SIZE,
          segment.getCapacityInBytes());
      assertEquals("Start offset is not equal to header size", LogSegment.HEADER_SIZE, segment.getStartOffset());
      int writeSize = 100;
      byte[] buf = TestUtils.getRandomBytes(3 * writeSize);
      long writeStartOffset = segment.getStartOffset();
      // append with buffer
      int written = segment.appendFrom(ByteBuffer.wrap(buf, 0, writeSize));
      assertEquals("Size written did not match size of buffer provided", writeSize, written);
      assertEquals("End offset is not as expected", writeStartOffset + writeSize, segment.getEndOffset());
      readAndEnsureMatch(segment, writeStartOffset, Arrays.copyOfRange(buf, 0, writeSize));

      // append with channel
      segment.appendFrom(Channels.newChannel(new ByteBufferInputStream(ByteBuffer.wrap(buf, writeSize, writeSize))),
          writeSize);
      assertEquals("End offset is not as expected", writeStartOffset + 2 * writeSize, segment.getEndOffset());
      readAndEnsureMatch(segment, writeStartOffset + writeSize, Arrays.copyOfRange(buf, writeSize, 2 * writeSize));

      // should throw exception if channel's available data less than requested.
      try {
        segment.appendFrom(Channels.newChannel(new ByteBufferInputStream(ByteBuffer.allocate(writeSize))),
            writeSize + 1);
        fail("Should throw exception.");
      } catch (StoreException e) {
      }

      // use writeFrom
      segment.writeFrom(Channels.newChannel(new ByteBufferInputStream(ByteBuffer.wrap(buf, 2 * writeSize, writeSize))),
          segment.getEndOffset(), writeSize);
      assertEquals("End offset is not as expected", writeStartOffset + 3 * writeSize, segment.getEndOffset());
      readAndEnsureMatch(segment, writeStartOffset + 2 * writeSize, Arrays.copyOfRange(buf, 2 * writeSize, buf.length));

      readAndEnsureMatch(segment, writeStartOffset, buf);
      // check file size and end offset (they will not match)
      assertEquals("End offset is not equal to the cumulative bytes written", writeStartOffset + 3 * writeSize,
          segment.getEndOffset());
      assertEquals("Size in bytes is not equal to size written", writeStartOffset + 3 * writeSize,
          segment.sizeInBytes());
      assertEquals("Capacity is not equal to allocated size ", STANDARD_SEGMENT_SIZE, segment.getCapacityInBytes());

      // ensure flush doesn't throw any errors.
      segment.flush();
      // close and reopen segment and ensure persistence.
      segment.close(false);
      segment = new LogSegment(segmentName, new File(tempDir, segmentName.toFilename()), config, metrics);
      segment.setEndOffset(writeStartOffset + buf.length);
      readAndEnsureMatch(segment, writeStartOffset, buf);
    } finally {
      closeSegmentAndDeleteFile(segment);
    }
  }
Tests appending and reading to make sure data is written and the data read is consistent with the data written.
@throws IOException
ambry-store/src/test/java/com/github/ambry/store/LogSegmentTest.java