/src/mozilla-central/gfx/2d/unittest/TestScaling.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "TestScaling.h"

#include "ImageScaling.h"

using namespace mozilla::gfx;

TestScaling::TestScaling()
{
  REGISTER_TEST(TestScaling, BasicHalfScale);
  REGISTER_TEST(TestScaling, DoubleHalfScale);
  REGISTER_TEST(TestScaling, UnevenHalfScale);
  REGISTER_TEST(TestScaling, OddStrideHalfScale);
  REGISTER_TEST(TestScaling, VerticalHalfScale);
  REGISTER_TEST(TestScaling, HorizontalHalfScale);
  REGISTER_TEST(TestScaling, MixedHalfScale);
}

void
TestScaling::BasicHalfScale()
{
  std::vector<uint8_t> data;
  data.resize(500 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 500 + x] = 0xff00ff00;
      pixels[y * 500 + x + 1] = 0xff00ffff;
      pixels[(y + 1) * 500 + x] = 0xff000000;
      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    }
  }
  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));

  scaler.ScaleForSize(IntSize(220, 240));

  VERIFY(scaler.GetSize().width == 250);
  VERIFY(scaler.GetSize().height == 250);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 250; y++) {
    for (int x = 0; x < 250; x++) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    }
  }
}

void
TestScaling::DoubleHalfScale()
{
  std::vector<uint8_t> data;
  data.resize(500 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 500 + x] = 0xff00ff00;
      pixels[y * 500 + x + 1] = 0xff00ffff;
      pixels[(y + 1) * 500 + x] = 0xff000000;
      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    }
  }
  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));

  scaler.ScaleForSize(IntSize(120, 110));
  VERIFY(scaler.GetSize().width == 125);
  VERIFY(scaler.GetSize().height == 125);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 125; y++) {
    for (int x = 0; x < 125; x++) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    }
  }
}

void
TestScaling::UnevenHalfScale()
{
  std::vector<uint8_t> data;
  // Use a 16-byte aligned stride still, we test none-aligned strides
  // separately.
  data.resize(499 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 500 + x] = 0xff00ff00;
      if (x < 498) {
        pixels[y * 500 + x + 1] = 0xff00ffff;
      }
      if (y < 498) {
        pixels[(y + 1) * 500 + x] = 0xff000000;
        if (x < 498) {
          pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
        }
      }
    }
  }
  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(499, 499));

  scaler.ScaleForSize(IntSize(220, 220));
  VERIFY(scaler.GetSize().width == 249);
  VERIFY(scaler.GetSize().height == 249);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 249; y++) {
    for (int x = 0; x < 249; x++) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    }
  }
}

void
TestScaling::OddStrideHalfScale()
{
  std::vector<uint8_t> data;
  // Use a 4-byte aligned stride to test if that doesn't cause any issues.
  data.resize(499 * 499 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 499 + x] = 0xff00ff00;
      if (x < 498) {
        pixels[y * 499 + x + 1] = 0xff00ffff;
      }
      if (y < 498) {
        pixels[(y + 1) * 499 + x] = 0xff000000;
        if (x < 498) {
          pixels[(y + 1) * 499 + x + 1] = 0xff0000ff;
        }
      }
    }
  }
  ImageHalfScaler scaler(&data.front(), 499 * 4, IntSize(499, 499));

  scaler.ScaleForSize(IntSize(220, 220));
  VERIFY(scaler.GetSize().width == 249);
  VERIFY(scaler.GetSize().height == 249);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 249; y++) {
    for (int x = 0; x < 249; x++) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    }
  }
}
void
TestScaling::VerticalHalfScale()
{
  std::vector<uint8_t> data;
  data.resize(500 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 500 + x] = 0xff00ff00;
      pixels[y * 500 + x + 1] = 0xff00ffff;
      pixels[(y + 1) * 500 + x] = 0xff000000;
      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    }
  }
  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));

  scaler.ScaleForSize(IntSize(400, 240));
  VERIFY(scaler.GetSize().width == 500);
  VERIFY(scaler.GetSize().height == 250);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 250; y++) {
    for (int x = 0; x < 500; x += 2) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f00);
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff007fff);
    }
  }
}

void
TestScaling::HorizontalHalfScale()
{
  std::vector<uint8_t> data;
  data.resize(520 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y ++) {
    for (int x = 0; x < 520; x += 8) {
      pixels[y * 520 + x] = 0xff00ff00;
      pixels[y * 520 + x + 1] = 0xff00ffff;
      pixels[y * 520 + x + 2] = 0xff000000;
      pixels[y * 520 + x + 3] = 0xff0000ff;
      pixels[y * 520 + x + 4] = 0xffff00ff;
      pixels[y * 520 + x + 5] = 0xff0000ff;
      pixels[y * 520 + x + 6] = 0xffffffff;
      pixels[y * 520 + x + 7] = 0xff0000ff;
    }
  }
  ImageHalfScaler scaler(&data.front(), 520 * 4, IntSize(520, 500));

  scaler.ScaleForSize(IntSize(240, 400));
  VERIFY(scaler.GetSize().width == 260);
  VERIFY(scaler.GetSize().height == 500);

  pixels = (uint32_t*)scaler.GetScaledData();

  for (int y = 0; y < 500; y++) {
    for (int x = 0; x < 260; x += 4) {
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff00ff7f);
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff00007f);
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 2] == 0xff7f00ff);
      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 3] == 0xff7f7fff);
    }
  }
}

void
TestScaling::MixedHalfScale()
{
  std::vector<uint8_t> data;
  data.resize(500 * 500 * 4);

  uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
  for (int y = 0; y < 500; y += 2) {
    for (int x = 0; x < 500; x += 2) {
      pixels[y * 500 + x] = 0xff00ff00;
      pixels[y * 500 + x + 1] = 0xff00ffff;
      pixels[(y + 1) * 500 + x] = 0xff000000;
      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    }
  }
  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));

  scaler.ScaleForSize(IntSize(120, 240));
  VERIFY(scaler.GetSize().width == 125);
  VERIFY(scaler.GetSize().height == 250);
  scaler.ScaleForSize(IntSize(240, 120));
  VERIFY(scaler.GetSize().width == 250);
  VERIFY(scaler.GetSize().height == 125);
}

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		/* -- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2		/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3		/* This Source Code Form is subject to the terms of the Mozilla Public
4		* License, v. 2.0. If a copy of the MPL was not distributed with this
5		* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7		#include "TestScaling.h"
8
9		#include "ImageScaling.h"
10
11		using namespace mozilla::gfx;
12
13		TestScaling::TestScaling()
14	0	{
15	0	REGISTER_TEST(TestScaling, BasicHalfScale);
16	0	REGISTER_TEST(TestScaling, DoubleHalfScale);
17	0	REGISTER_TEST(TestScaling, UnevenHalfScale);
18	0	REGISTER_TEST(TestScaling, OddStrideHalfScale);
19	0	REGISTER_TEST(TestScaling, VerticalHalfScale);
20	0	REGISTER_TEST(TestScaling, HorizontalHalfScale);
21	0	REGISTER_TEST(TestScaling, MixedHalfScale);
22	0	}
23
24		void
25		TestScaling::BasicHalfScale()
26	0	{
27	0	std::vector<uint8_t> data;
28	0	data.resize(500 * 500 * 4);
29	0
30	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
31	0	for (int y = 0; y < 500; y += 2) {
32	0	for (int x = 0; x < 500; x += 2) {
33	0	pixels[y * 500 + x] = 0xff00ff00;
34	0	pixels[y * 500 + x + 1] = 0xff00ffff;
35	0	pixels[(y + 1) * 500 + x] = 0xff000000;
36	0	pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
37	0	}
38	0	}
39	0	ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
40	0
41	0	scaler.ScaleForSize(IntSize(220, 240));
42	0
43	0	VERIFY(scaler.GetSize().width == 250);
44	0	VERIFY(scaler.GetSize().height == 250);
45	0
46	0	pixels = (uint32_t*)scaler.GetScaledData();
47	0
48	0	for (int y = 0; y < 250; y++) {
49	0	for (int x = 0; x < 250; x++) {
50	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
51	0	}
52	0	}
53	0	}
54
55		void
56		TestScaling::DoubleHalfScale()
57	0	{
58	0	std::vector<uint8_t> data;
59	0	data.resize(500 * 500 * 4);
60	0
61	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
62	0	for (int y = 0; y < 500; y += 2) {
63	0	for (int x = 0; x < 500; x += 2) {
64	0	pixels[y * 500 + x] = 0xff00ff00;
65	0	pixels[y * 500 + x + 1] = 0xff00ffff;
66	0	pixels[(y + 1) * 500 + x] = 0xff000000;
67	0	pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
68	0	}
69	0	}
70	0	ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
71	0
72	0	scaler.ScaleForSize(IntSize(120, 110));
73	0	VERIFY(scaler.GetSize().width == 125);
74	0	VERIFY(scaler.GetSize().height == 125);
75	0
76	0	pixels = (uint32_t*)scaler.GetScaledData();
77	0
78	0	for (int y = 0; y < 125; y++) {
79	0	for (int x = 0; x < 125; x++) {
80	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
81	0	}
82	0	}
83	0	}
84
85		void
86		TestScaling::UnevenHalfScale()
87	0	{
88	0	std::vector<uint8_t> data;
89	0	// Use a 16-byte aligned stride still, we test none-aligned strides
90	0	// separately.
91	0	data.resize(499 * 500 * 4);
92	0
93	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
94	0	for (int y = 0; y < 500; y += 2) {
95	0	for (int x = 0; x < 500; x += 2) {
96	0	pixels[y * 500 + x] = 0xff00ff00;
97	0	if (x < 498) {
98	0	pixels[y * 500 + x + 1] = 0xff00ffff;
99	0	}
100	0	if (y < 498) {
101	0	pixels[(y + 1) * 500 + x] = 0xff000000;
102	0	if (x < 498) {
103	0	pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
104	0	}
105	0	}
106	0	}
107	0	}
108	0	ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(499, 499));
109	0
110	0	scaler.ScaleForSize(IntSize(220, 220));
111	0	VERIFY(scaler.GetSize().width == 249);
112	0	VERIFY(scaler.GetSize().height == 249);
113	0
114	0	pixels = (uint32_t*)scaler.GetScaledData();
115	0
116	0	for (int y = 0; y < 249; y++) {
117	0	for (int x = 0; x < 249; x++) {
118	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
119	0	}
120	0	}
121	0	}
122
123		void
124		TestScaling::OddStrideHalfScale()
125	0	{
126	0	std::vector<uint8_t> data;
127	0	// Use a 4-byte aligned stride to test if that doesn't cause any issues.
128	0	data.resize(499 * 499 * 4);
129	0
130	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
131	0	for (int y = 0; y < 500; y += 2) {
132	0	for (int x = 0; x < 500; x += 2) {
133	0	pixels[y * 499 + x] = 0xff00ff00;
134	0	if (x < 498) {
135	0	pixels[y * 499 + x + 1] = 0xff00ffff;
136	0	}
137	0	if (y < 498) {
138	0	pixels[(y + 1) * 499 + x] = 0xff000000;
139	0	if (x < 498) {
140	0	pixels[(y + 1) * 499 + x + 1] = 0xff0000ff;
141	0	}
142	0	}
143	0	}
144	0	}
145	0	ImageHalfScaler scaler(&data.front(), 499 * 4, IntSize(499, 499));
146	0
147	0	scaler.ScaleForSize(IntSize(220, 220));
148	0	VERIFY(scaler.GetSize().width == 249);
149	0	VERIFY(scaler.GetSize().height == 249);
150	0
151	0	pixels = (uint32_t*)scaler.GetScaledData();
152	0
153	0	for (int y = 0; y < 249; y++) {
154	0	for (int x = 0; x < 249; x++) {
155	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
156	0	}
157	0	}
158	0	}
159		void
160		TestScaling::VerticalHalfScale()
161	0	{
162	0	std::vector<uint8_t> data;
163	0	data.resize(500 * 500 * 4);
164	0
165	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
166	0	for (int y = 0; y < 500; y += 2) {
167	0	for (int x = 0; x < 500; x += 2) {
168	0	pixels[y * 500 + x] = 0xff00ff00;
169	0	pixels[y * 500 + x + 1] = 0xff00ffff;
170	0	pixels[(y + 1) * 500 + x] = 0xff000000;
171	0	pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
172	0	}
173	0	}
174	0	ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
175	0
176	0	scaler.ScaleForSize(IntSize(400, 240));
177	0	VERIFY(scaler.GetSize().width == 500);
178	0	VERIFY(scaler.GetSize().height == 250);
179	0
180	0	pixels = (uint32_t*)scaler.GetScaledData();
181	0
182	0	for (int y = 0; y < 250; y++) {
183	0	for (int x = 0; x < 500; x += 2) {
184	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f00);
185	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff007fff);
186	0	}
187	0	}
188	0	}
189
190		void
191		TestScaling::HorizontalHalfScale()
192	0	{
193	0	std::vector<uint8_t> data;
194	0	data.resize(520 * 500 * 4);
195	0
196	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
197	0	for (int y = 0; y < 500; y ++) {
198	0	for (int x = 0; x < 520; x += 8) {
199	0	pixels[y * 520 + x] = 0xff00ff00;
200	0	pixels[y * 520 + x + 1] = 0xff00ffff;
201	0	pixels[y * 520 + x + 2] = 0xff000000;
202	0	pixels[y * 520 + x + 3] = 0xff0000ff;
203	0	pixels[y * 520 + x + 4] = 0xffff00ff;
204	0	pixels[y * 520 + x + 5] = 0xff0000ff;
205	0	pixels[y * 520 + x + 6] = 0xffffffff;
206	0	pixels[y * 520 + x + 7] = 0xff0000ff;
207	0	}
208	0	}
209	0	ImageHalfScaler scaler(&data.front(), 520 * 4, IntSize(520, 500));
210	0
211	0	scaler.ScaleForSize(IntSize(240, 400));
212	0	VERIFY(scaler.GetSize().width == 260);
213	0	VERIFY(scaler.GetSize().height == 500);
214	0
215	0	pixels = (uint32_t*)scaler.GetScaledData();
216	0
217	0	for (int y = 0; y < 500; y++) {
218	0	for (int x = 0; x < 260; x += 4) {
219	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff00ff7f);
220	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff00007f);
221	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 2] == 0xff7f00ff);
222	0	VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 3] == 0xff7f7fff);
223	0	}
224	0	}
225	0	}
226
227		void
228		TestScaling::MixedHalfScale()
229	0	{
230	0	std::vector<uint8_t> data;
231	0	data.resize(500 * 500 * 4);
232	0
233	0	uint32_t pixels = reinterpret_cast<uint32_t>(&data.front());
234	0	for (int y = 0; y < 500; y += 2) {
235	0	for (int x = 0; x < 500; x += 2) {
236	0	pixels[y * 500 + x] = 0xff00ff00;
237	0	pixels[y * 500 + x + 1] = 0xff00ffff;
238	0	pixels[(y + 1) * 500 + x] = 0xff000000;
239	0	pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
240	0	}
241	0	}
242	0	ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
243	0
244	0	scaler.ScaleForSize(IntSize(120, 240));
245	0	VERIFY(scaler.GetSize().width == 125);
246	0	VERIFY(scaler.GetSize().height == 250);
247	0	scaler.ScaleForSize(IntSize(240, 120));
248	0	VERIFY(scaler.GetSize().width == 250);
249	0	VERIFY(scaler.GetSize().height == 125);
250	0	}