third_party/WebKit/Source/platform/image-decoders/FastSharedBufferReaderTest.cpp

/*
 * Copyright (C) 2015 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "platform/image-decoders/FastSharedBufferReader.h"
#include "platform/image-decoders/SegmentReader.h"

#include "testing/gtest/include/gtest/gtest.h"

namespace blink {

namespace {

const unsigned kDefaultTestSize = 4 * SharedBuffer::kSegmentSize;

void prepareReferenceData(char* buffer, size_t size)
{
    for (size_t i = 0; i < size; ++i)
        buffer[i] = static_cast<char>(i);
}

PassRefPtr<SegmentReader> copyToROBufferSegmentReader(PassRefPtr<SegmentReader> input)
{
    SkRWBuffer rwBuffer;
    const char* segment = 0;
    size_t position = 0;
    while (size_t length = input->getSomeData(segment, position)) {
        rwBuffer.append(segment, length);
        position += length;
    }
    return SegmentReader::createFromSkROBuffer(adoptRef(rwBuffer.newRBufferSnapshot()));
}

PassRefPtr<SegmentReader> copyToDataSegmentReader(PassRefPtr<SegmentReader> input)
{
    return SegmentReader::createFromSkData(input->getAsSkData());
}

struct SegmentReaders {
    RefPtr<SegmentReader> segmentReaders[3];

    SegmentReaders(PassRefPtr<SharedBuffer> input)
    {
        segmentReaders[0] = SegmentReader::createFromSharedBuffer(input);
        segmentReaders[1] = copyToROBufferSegmentReader(segmentReaders[0]);
        segmentReaders[2] = copyToDataSegmentReader(segmentReaders[0]);
    }
};

} // namespace

TEST(FastSharedBufferReaderTest, nonSequentialReads)
{
    char referenceData[kDefaultTestSize];
    prepareReferenceData(referenceData, sizeof(referenceData));
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, sizeof(referenceData));

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        FastSharedBufferReader reader(segmentReader);
        // Read size is prime such there will be a segment-spanning
        // read eventually.
        char tempBuffer[17];
        for (size_t dataPosition = 0; dataPosition + sizeof(tempBuffer) < sizeof(referenceData); dataPosition += sizeof(tempBuffer)) {
            const char* block = reader.getConsecutiveData(
                dataPosition, sizeof(tempBuffer), tempBuffer);
            ASSERT_FALSE(memcmp(block, referenceData + dataPosition, sizeof(tempBuffer)));
        }
    }
}

TEST(FastSharedBufferReaderTest, readBackwards)
{
    char referenceData[kDefaultTestSize];
    prepareReferenceData(referenceData, sizeof(referenceData));
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, sizeof(referenceData));

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        FastSharedBufferReader reader(segmentReader);
        // Read size is prime such there will be a segment-spanning
        // read eventually.
        char tempBuffer[17];
        for (size_t dataOffset = sizeof(tempBuffer); dataOffset < sizeof(referenceData); dataOffset += sizeof(tempBuffer)) {
            const char* block = reader.getConsecutiveData(
                sizeof(referenceData) - dataOffset, sizeof(tempBuffer), tempBuffer);
            ASSERT_FALSE(memcmp(block, referenceData + sizeof(referenceData) - dataOffset, sizeof(tempBuffer)));
        }
    }
}

TEST(FastSharedBufferReaderTest, byteByByte)
{
    char referenceData[kDefaultTestSize];
    prepareReferenceData(referenceData, sizeof(referenceData));
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, sizeof(referenceData));

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        FastSharedBufferReader reader(segmentReader);
        for (size_t i = 0; i < sizeof(referenceData); ++i) {
            ASSERT_EQ(referenceData[i], reader.getOneByte(i));
        }
    }
}

// Tests that a read from inside the penultimate segment to the very end of the
// buffer doesn't try to read off the end of the buffer.
TEST(FastSharedBufferReaderTest, readAllOverlappingLastSegmentBoundary)
{
    const unsigned dataSize = 2 * SharedBuffer::kSegmentSize;
    char referenceData[dataSize];
    prepareReferenceData(referenceData, dataSize);
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, dataSize);

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        FastSharedBufferReader reader(segmentReader);
        char buffer[dataSize];
        reader.getConsecutiveData(0, dataSize, buffer);
        ASSERT_FALSE(memcmp(buffer, referenceData, dataSize));
    }
}

// Verify that reading past the end of the buffer does not break future reads.
TEST(SegmentReaderTest, readPastEndThenRead)
{
    const unsigned dataSize = 2 * SharedBuffer::kSegmentSize;
    char referenceData[dataSize];
    prepareReferenceData(referenceData, dataSize);
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, dataSize);

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        const char* contents;
        size_t length = segmentReader->getSomeData(contents, dataSize);
        EXPECT_EQ(0u, length);

        length = segmentReader->getSomeData(contents, 0);
        EXPECT_LE(SharedBuffer::kSegmentSize, length);
    }
}

TEST(SegmentReaderTest, getAsSkData)
{
    const unsigned dataSize = 4 * SharedBuffer::kSegmentSize;
    char referenceData[dataSize];
    prepareReferenceData(referenceData, dataSize);
    RefPtr<SharedBuffer> data = SharedBuffer::create();
    data->append(referenceData, dataSize);

    SegmentReaders readerStruct(data);
    for (auto segmentReader : readerStruct.segmentReaders) {
        RefPtr<SkData> skdata = segmentReader->getAsSkData();
        EXPECT_EQ(data->size(), skdata->size());

        const char* segment;
        size_t position = 0;
        for (size_t length = segmentReader->getSomeData(segment, position);
            length; length = segmentReader->getSomeData(segment, position)) {
            ASSERT_FALSE(memcmp(segment, skdata->bytes() + position, length));
            position += length;
        }
        EXPECT_EQ(position, dataSize);
    }
}

TEST(SegmentReaderTest, variableSegments)
{
    const size_t dataSize = 3.5 * SharedBuffer::kSegmentSize;
    char referenceData[dataSize];
    prepareReferenceData(referenceData, dataSize);

    RefPtr<SegmentReader> segmentReader;
    {
        // Create a SegmentReader with difference sized segments, to test that
        // the SkROBuffer implementation works when two consecutive segments
        // are not the same size. This test relies on knowledge of the
        // internals of SkRWBuffer: it ensures that each segment is at least
        // 4096 (though the actual data may be smaller, if it has not been
        // written to yet), but when appending a larger amount it may create a
        // larger segment.
        SkRWBuffer rwBuffer;
        rwBuffer.append(referenceData, SharedBuffer::kSegmentSize);
        rwBuffer.append(referenceData + SharedBuffer::kSegmentSize, 2 * SharedBuffer::kSegmentSize);
        rwBuffer.append(referenceData + 3 * SharedBuffer::kSegmentSize, .5 * SharedBuffer::kSegmentSize);

        segmentReader = SegmentReader::createFromSkROBuffer(adoptRef(rwBuffer.newRBufferSnapshot()));
    }

    const char* segment;
    size_t position = 0;
    size_t lastLength = 0;
    for (size_t length = segmentReader->getSomeData(segment, position);
        length; length = segmentReader->getSomeData(segment, position)) {
        // It is not a bug to have consecutive segments of the same length, but
        // it does mean that the following test does not actually test what it
        // is intended to test.
        ASSERT_NE(length, lastLength);
        lastLength = length;

        ASSERT_FALSE(memcmp(segment, referenceData + position, length));
        position += length;
    }
    EXPECT_EQ(position, dataSize);
}

} // namespace blink