~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

QImage subimage(((const QImage &) original).bits(), 32, 32, original.bytesPerLine(), QImage::Format_RGB32); // only in the black part of the source...

1790

1791

QImage scaled = subimage.scaled(8, 8, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

1792

1793

for (int y=0; y<scaled.height(); ++y)

1794

for (int x=0; x<scaled.width(); ++x)

1795

QCOMPARE(scaled.pixel(x, y), 0xff000000);

1796

}

1797

1798

void tst_QImage::nullSize_data()

1799

{

1800

QTest::addColumn<QImage>("image");

1801

QTest::newRow("null image") << QImage();

1802

QTest::newRow("zero-size image") << QImage(0, 0, QImage::Format_RGB32);

1803

}

1804

1805

void tst_QImage::nullSize()

1806

{

1807

QFETCH(QImage, image);

1808

QCOMPARE(image.isNull(), true);

1809

QCOMPARE(image.width(), image.size().width());

1810

QCOMPARE(image.height(), image.size().height());

1811

}

1812

1813

void tst_QImage::premultipliedAlphaConsistency()

1814

{

1815

QImage img(256, 1, QImage::Format_ARGB32);

1816

for (int x = 0; x < 256; ++x)

1817

img.setPixel(x, 0, (x << 24) | 0xffffff);

1818

1819

QImage converted = img.convertToFormat(QImage::Format_ARGB8565_Premultiplied);

1820

QImage pm32 = converted.convertToFormat(QImage::Format_ARGB32_Premultiplied);

1821

1822

for (int i = 0; i < pm32.width(); ++i) {

1823

QRgb pixel = pm32.pixel(i, 0);

1824

QVERIFY(qRed(pixel) <= qAlpha(pixel));

1825

QVERIFY(qGreen(pixel) <= qAlpha(pixel));

1826

QVERIFY(qBlue(pixel) <= qAlpha(pixel));

1827

}

1828

}

1829

1830

void tst_QImage::compareIndexed()

1831

{

1832

QImage img(256, 1, QImage::Format_Indexed8);

1833

1834

QVector<QRgb> colorTable(256);

1835

for (int i = 0; i < 256; ++i)

1836

colorTable[i] = qRgb(i, i, i);

1837

img.setColorTable(colorTable);

1838

1839

for (int i = 0; i < 256; ++i) {

1840

img.setPixel(i, 0, i);

1841

}

1842

1843

QImage imgInverted(256, 1, QImage::Format_Indexed8);

1844

QVector<QRgb> invertedColorTable(256);

1845

for (int i = 0; i < 256; ++i)

1846

invertedColorTable[255-i] = qRgb(i, i, i);

1847

imgInverted.setColorTable(invertedColorTable);

1848

1849

for (int i = 0; i < 256; ++i) {

1850

imgInverted.setPixel(i, 0, (255-i));

1851

}

1852

1853

QCOMPARE(img, imgInverted);

1854

}

1855

1856

void tst_QImage::fillColor_data()

1857

{

1858

QTest::addColumn<QImage::Format>("format");

1859

QTest::addColumn<Qt::GlobalColor>("color");

1860

QTest::addColumn<uint>("pixelValue");

1861

1862

QTest::newRow("Mono, color0") << QImage::Format_Mono << Qt::color0 << 0u;

1863

QTest::newRow("Mono, color1") << QImage::Format_Mono << Qt::color1 << 1u;

1864

1865

QTest::newRow("MonoLSB, color0") << QImage::Format_MonoLSB << Qt::color0 << 0u;

1866

QTest::newRow("MonoLSB, color1") << QImage::Format_MonoLSB << Qt::color1 << 1u;

1867

1868

const char *names[] = {

1869

"Indexed8",

1870

"RGB32",

1871

"ARGB32",

1872

"ARGB32pm",

1873

"RGB16",

1874

"ARGB8565pm",

1875

"RGB666",

1876

"ARGB6666pm",

1877

"RGB555",

1878

"ARGB8555pm",

1879

"RGB888",

1880

"RGB444",

1881

"ARGB4444pm",

1882

1883

};

1884

1885

QImage::Format formats[] = {

1886

QImage::Format_Indexed8,

1887

QImage::Format_RGB32,

1888

QImage::Format_ARGB32,

1889

QImage::Format_ARGB32_Premultiplied,

1890

QImage::Format_RGB16,

1891

QImage::Format_ARGB8565_Premultiplied,

1892

QImage::Format_RGB666,

1893

QImage::Format_ARGB6666_Premultiplied,

1894

QImage::Format_RGB555,

1895

QImage::Format_ARGB8555_Premultiplied,

1896

QImage::Format_RGB888,

1897

QImage::Format_RGB444,

1898

QImage::Format_ARGB4444_Premultiplied

1899

};

1900

1901

for (int i=0; names[i] != 0; ++i) {

1902

QByteArray name;

1903

name.append(names[i]).append(", ");

1904

1905

QTest::newRow(QByteArray(name).append("black").constData()) << formats[i] << Qt::black << 0xff000000;

1906

QTest::newRow(QByteArray(name).append("white").constData()) << formats[i] << Qt::white << 0xffffffff;

1907

QTest::newRow(QByteArray(name).append("red").constData()) << formats[i] << Qt::red << 0xffff0000;

1908

QTest::newRow(QByteArray(name).append("green").constData()) << formats[i] << Qt::green << 0xff00ff00;

1909

QTest::newRow(QByteArray(name).append("blue").constData()) << formats[i] << Qt::blue << 0xff0000ff;

1910

}

1911

1912

QTest::newRow("RGB16, transparent") << QImage::Format_RGB16 << Qt::transparent << 0xff000000;

1913

QTest::newRow("RGB32, transparent") << QImage::Format_RGB32 << Qt::transparent << 0xff000000;

1914

QTest::newRow("ARGB32, transparent") << QImage::Format_ARGB32 << Qt::transparent << 0x00000000u;

1915

QTest::newRow("ARGB32pm, transparent") << QImage::Format_ARGB32_Premultiplied << Qt::transparent << 0x00000000u;

1916

}

1917

1918

void tst_QImage::fillColor()

1919

{

1920

QFETCH(QImage::Format, format);

1921

QFETCH(Qt::GlobalColor, color);

1922

QFETCH(uint, pixelValue);

1923

1924

QImage image(1, 1, format);

1925

1926

if (image.depth() == 8) {

1927

QVector<QRgb> table;

1928

table << 0xff000000;

1929

table << 0xffffffff;

1930

table << 0xffff0000;

1931

table << 0xff00ff00;

1932

table << 0xff0000ff;

1933

image.setColorTable(table);

1934

}

1935

1936

image.fill(color);

1937

if (image.depth() == 1) {

1938

QCOMPARE(image.pixelIndex(0, 0), (int) pixelValue);

1939

} else {

1940

QCOMPARE(image.pixel(0, 0), pixelValue);

1941

}

1942

1943

image.fill(QColor(color));

1944

if (image.depth() == 1) {

1945

QCOMPARE(image.pixelIndex(0, 0), (int) pixelValue);

1946

} else {

1947

QCOMPARE(image.pixel(0, 0), pixelValue);

1948

}

1949

}

1950

1951

void tst_QImage::fillColorWithAlpha()

1952

{

1953

QImage argb32(1, 1, QImage::Format_ARGB32);

1954

argb32.fill(QColor(255, 0, 0, 127));

1955

QCOMPARE(argb32.pixel(0, 0), qRgba(255, 0, 0, 127));

1956

1957

QImage argb32pm(1, 1, QImage::Format_ARGB32_Premultiplied);

1958

argb32pm.fill(QColor(255, 0, 0, 127));

1959

QCOMPARE(argb32pm.pixel(0, 0), 0x7f7f0000u);

1960

}

1961

1962

void tst_QImage::fillRGB888()

1963

{

1964

QImage expected(1, 1, QImage::Format_RGB888);

1965

QImage actual(1, 1, QImage::Format_RGB888);

1966

1967

for (int c = Qt::black; c < Qt::transparent; ++c) {

1968

QColor color = QColor(Qt::GlobalColor(c));

1969

1970

expected.fill(color);

1971

actual.fill(color.rgba());

1972

1973

QCOMPARE(actual.pixel(0, 0), expected.pixel(0, 0));

1974

}

1975

}

1976

1977

void tst_QImage::rgbSwapped_data()

1978

{

1979

QTest::addColumn<QImage::Format>("format");

1980

1981

QTest::newRow("Format_Indexed8") << QImage::Format_Indexed8;

1982

QTest::newRow("Format_RGB32") << QImage::Format_RGB32;

1983

QTest::newRow("Format_ARGB32") << QImage::Format_ARGB32;

1984

QTest::newRow("Format_ARGB32_Premultiplied") << QImage::Format_ARGB32_Premultiplied;

1985

QTest::newRow("Format_RGB16") << QImage::Format_RGB16;

1986

QTest::newRow("Format_ARGB8565_Premultiplied") << QImage::Format_ARGB8565_Premultiplied;

1987

QTest::newRow("Format_ARGB6666_Premultiplied") << QImage::Format_ARGB6666_Premultiplied;

1988

QTest::newRow("Format_ARGB4444_Premultiplied") << QImage::Format_ARGB4444_Premultiplied;

1989

QTest::newRow("Format_RGB666") << QImage::Format_RGB666;

1990

QTest::newRow("Format_RGB555") << QImage::Format_RGB555;

1991

QTest::newRow("Format_ARGB8555_Premultiplied") << QImage::Format_ARGB8555_Premultiplied;

1992

QTest::newRow("Format_RGB888") << QImage::Format_RGB888;

1993

QTest::newRow("Format_RGB444") << QImage::Format_RGB444;

1994

}

1995

1996

void tst_QImage::rgbSwapped()

1997

{

1998

QFETCH(QImage::Format, format);

1999

2000

QImage image(100, 1, format);

2001

image.fill(0);

2002

2003

QVector<QColor> testColor(image.width());

2004

2005

for (int i = 0; i < image.width(); ++i)

2006

testColor[i] = QColor(i, 10 + i, 20 + i * 2, 30 + i);

2007

2008

if (format != QImage::Format_Indexed8) {

2009

QPainter p(&image);

2010

p.setCompositionMode(QPainter::CompositionMode_Source);

2011

for (int i = 0; i < image.width(); ++i)

2012

p.fillRect(QRect(i, 0, 1, 1), testColor[i].rgb());

2013

} else {

2014

image.setColorCount(image.width());

2015

for (int i = 0; i < image.width(); ++i) {

2016

image.setColor(0, testColor[i].rgba());

2017

image.setPixel(i, 0, i);

2018

}

2019

}

2020

2021

QImage imageSwapped = image.rgbSwapped();

2022

2023

for (int i = 0; i < image.width(); ++i) {

2024

QColor referenceColor = QColor(image.pixel(i, 0));

2025

QColor swappedColor = QColor(imageSwapped.pixel(i, 0));

2026

2027

QCOMPARE(swappedColor.alpha(), referenceColor.alpha());

2028

QCOMPARE(swappedColor.red(), referenceColor.blue());

2029

QCOMPARE(swappedColor.green(), referenceColor.green());

2030

QCOMPARE(swappedColor.blue(), referenceColor.red());

2031

}

2032

2033

QImage imageSwappedTwice = imageSwapped.rgbSwapped();

2034

2035

QCOMPARE(image, imageSwappedTwice);

2036

2037

QCOMPARE(memcmp(image.constBits(), imageSwappedTwice.constBits(), image.byteCount()), 0);

2038

}

2039

2040

void tst_QImage::deepCopyWhenPaintingActive()

2041

{

2042

QImage image(64, 64, QImage::Format_ARGB32_Premultiplied);

2043

image.fill(0);

2044

2045

QPainter painter(&image);

2046

QImage copy = image;

2047

2048

painter.setBrush(Qt::black);

2049

painter.drawEllipse(image.rect());

2050

2051

QVERIFY(copy != image);

2052

}

2053

2054

void tst_QImage::scaled_QTBUG19157()

2055

{

2056

QImage foo(5000, 1, QImage::Format_RGB32);

2057

foo = foo.scaled(1024, 1024, Qt::KeepAspectRatio);

2058

QVERIFY(!foo.isNull());

2059

}

2060

2061

static void cleanupFunction(void* info)

2062

{

2063

bool *called = static_cast<bool*>(info);

2064

*called = true;

2065

}

2066

2067

void tst_QImage::cleanupFunctions()

2068

{

2069

QImage bufferImage(64, 64, QImage::Format_ARGB32);

2070

bufferImage.fill(0);

2071

2072

bool called;

2073

2074

{

2075

called = false;

2076

{

2077

QImage image(bufferImage.bits(), bufferImage.width(), bufferImage.height(), bufferImage.format(), cleanupFunction, &called);

2078

}

2079

QVERIFY(called);

2080

}

2081

2082

{

2083

called = false;

2084

QImage *copy = 0;

2085

{

2086

QImage image(bufferImage.bits(), bufferImage.width(), bufferImage.height(), bufferImage.format(), cleanupFunction, &called);

2087

copy = new QImage(image);

2088

}

2089

QVERIFY(!called);

2090

delete copy;

2091

QVERIFY(called);

2092

}

2093

2094

}

2095

2096

QTEST_MAIN(tst_QImage)

2097

#include "tst_qimage.moc"

Older »