2020-08-04 02:30:37 +03:00
|
|
|
/**
|
|
|
|
* Copyright 2018 Google Inc. All rights reserved.
|
|
|
|
* Modifications copyright (c) Microsoft Corporation.
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
2020-08-20 07:32:12 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
import { test as it, expect } from './config/pageTest';
|
|
|
|
import { test as browserTest, slowTest as slowBrowserTest } from './config/browserTest';
|
2021-04-06 01:51:45 +03:00
|
|
|
import { verifyViewport } from './config/utils';
|
2020-08-18 02:53:19 +03:00
|
|
|
import path from 'path';
|
|
|
|
import fs from 'fs';
|
2020-10-11 07:50:37 +03:00
|
|
|
import { PNG } from 'pngjs';
|
2020-08-18 02:53:19 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it.describe('page screenshot', () => {
|
|
|
|
it.beforeEach(async ({ browserName, headful }) => {
|
|
|
|
it.skip(browserName === 'firefox' && headful, 'Firefox headful produces a different image.');
|
|
|
|
it.skip(!!process.env.PW_ANDROID_TESTS, 'Different viewport');
|
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should work', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshot = await page.screenshot();
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-sanity.png');
|
2020-08-04 02:30:37 +03:00
|
|
|
});
|
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should clip rect', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshot = await page.screenshot({
|
|
|
|
clip: {
|
|
|
|
x: 50,
|
|
|
|
y: 100,
|
|
|
|
width: 150,
|
|
|
|
height: 100
|
|
|
|
}
|
|
|
|
});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-clip-rect.png');
|
2020-08-04 02:30:37 +03:00
|
|
|
});
|
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should clip rect with fullPage', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
await page.evaluate(() => window.scrollBy(150, 200));
|
|
|
|
const screenshot = await page.screenshot({
|
|
|
|
fullPage: true,
|
|
|
|
clip: {
|
|
|
|
x: 50,
|
|
|
|
y: 100,
|
|
|
|
width: 150,
|
|
|
|
height: 100,
|
|
|
|
},
|
|
|
|
});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-clip-rect.png');
|
2020-08-04 02:30:37 +03:00
|
|
|
});
|
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should clip elements to the viewport', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshot = await page.screenshot({
|
|
|
|
clip: {
|
|
|
|
x: 50,
|
|
|
|
y: 450,
|
|
|
|
width: 1000,
|
|
|
|
height: 100
|
|
|
|
}
|
|
|
|
});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-offscreen-clip.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should throw on clip outside the viewport', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshotError = await page.screenshot({
|
2020-08-04 02:30:37 +03:00
|
|
|
clip: {
|
2020-08-28 23:53:47 +03:00
|
|
|
x: 50,
|
|
|
|
y: 650,
|
|
|
|
width: 100,
|
|
|
|
height: 100
|
2020-08-04 02:30:37 +03:00
|
|
|
}
|
2020-08-28 23:53:47 +03:00
|
|
|
}).catch(error => error);
|
|
|
|
expect(screenshotError.message).toContain('Clipped area is either empty or outside the resulting image');
|
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should run in parallel', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const promises = [];
|
|
|
|
for (let i = 0; i < 3; ++i) {
|
|
|
|
promises.push(page.screenshot({
|
|
|
|
clip: {
|
|
|
|
x: 50 * i,
|
|
|
|
y: 0,
|
|
|
|
width: 50,
|
|
|
|
height: 50
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
const screenshots = await Promise.all(promises);
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshots[1]).toMatchSnapshot('grid-cell-1.png');
|
2020-08-04 02:30:37 +03:00
|
|
|
});
|
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should take fullPage screenshots', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshot = await page.screenshot({
|
|
|
|
fullPage: true
|
|
|
|
});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-grid-fullpage.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-08-28 23:53:47 +03:00
|
|
|
it('should restore viewport after fullPage screenshot', async ({page, server}) => {
|
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
2020-08-04 02:30:37 +03:00
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
2020-08-28 23:53:47 +03:00
|
|
|
const screenshot = await page.screenshot({ fullPage: true });
|
|
|
|
expect(screenshot).toBeInstanceOf(Buffer);
|
2020-09-19 01:52:14 +03:00
|
|
|
await verifyViewport(page, 500, 500);
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('should allow transparency', async ({page, browserName}) => {
|
|
|
|
it.fail(browserName === 'firefox');
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({ width: 50, height: 150 });
|
|
|
|
await page.setContent(`
|
|
|
|
<style>
|
|
|
|
body { margin: 0 }
|
|
|
|
div { width: 50px; height: 50px; }
|
|
|
|
</style>
|
|
|
|
<div style="background:black"></div>
|
|
|
|
<div style="background:white"></div>
|
|
|
|
<div style="background:transparent"></div>
|
|
|
|
`);
|
|
|
|
const screenshot = await page.screenshot({omitBackground: true});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('transparent.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should render white background on jpeg file', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({ width: 100, height: 100 });
|
|
|
|
await page.goto(server.EMPTY_PAGE);
|
|
|
|
const screenshot = await page.screenshot({omitBackground: true, type: 'jpeg'});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('white.jpg');
|
2020-08-04 02:30:37 +03:00
|
|
|
});
|
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should work with odd clip size on Retina displays', async ({page}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
const screenshot = await page.screenshot({
|
|
|
|
clip: {
|
|
|
|
x: 0,
|
|
|
|
y: 0,
|
|
|
|
width: 11,
|
|
|
|
height: 11,
|
|
|
|
}
|
|
|
|
});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-clip-odd-size.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should work for canvas', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/screenshots/canvas.html');
|
|
|
|
const screenshot = await page.screenshot();
|
2020-11-04 18:39:08 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-canvas.png', { threshold: 0.4 });
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('should work for webgl', async ({page, server, browserName}) => {
|
|
|
|
it.fixme(browserName === 'firefox' || browserName === 'webkit');
|
|
|
|
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 640, height: 480});
|
|
|
|
await page.goto(server.PREFIX + '/screenshots/webgl.html');
|
|
|
|
const screenshot = await page.screenshot();
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-webgl.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should work for translateZ', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/screenshots/translateZ.html');
|
|
|
|
const screenshot = await page.screenshot();
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-translateZ.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-08-28 23:53:47 +03:00
|
|
|
it('should work while navigating', async ({page, server}) => {
|
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/redirectloop1.html');
|
|
|
|
for (let i = 0; i < 10; i++) {
|
|
|
|
const screenshot = await page.screenshot({ fullPage: true }).catch(e => {
|
|
|
|
if (e.message.includes('Cannot take a screenshot while page is navigating'))
|
|
|
|
return Buffer.from('');
|
|
|
|
throw e;
|
|
|
|
});
|
|
|
|
expect(screenshot).toBeInstanceOf(Buffer);
|
|
|
|
}
|
|
|
|
});
|
2020-08-04 02:30:37 +03:00
|
|
|
|
2020-09-29 21:51:00 +03:00
|
|
|
it('should work with iframe in shadow', async ({page, server}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid-iframe-in-shadow.html');
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(await page.screenshot()).toMatchSnapshot('screenshot-iframe.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-18 02:53:19 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('path option should work', async ({page, server}, testInfo) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
2020-10-06 03:03:24 +03:00
|
|
|
const outputPath = testInfo.outputPath('screenshot.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.screenshot({path: outputPath});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(await fs.promises.readFile(outputPath)).toMatchSnapshot('screenshot-sanity.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-19 04:46:56 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('path option should create subdirectories', async ({page, server}, testInfo) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({width: 500, height: 500});
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
2020-10-06 03:03:24 +03:00
|
|
|
const outputPath = testInfo.outputPath(path.join('these', 'are', 'directories', 'screenshot.png'));
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.screenshot({path: outputPath});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(await fs.promises.readFile(outputPath)).toMatchSnapshot('screenshot-sanity.png');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
2020-08-19 04:46:56 +03:00
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('path option should detect jpeg', async ({page, server}, testInfo) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
await page.setViewportSize({ width: 100, height: 100 });
|
|
|
|
await page.goto(server.EMPTY_PAGE);
|
2020-10-06 03:03:24 +03:00
|
|
|
const outputPath = testInfo.outputPath('screenshot.jpg');
|
2020-08-28 23:53:47 +03:00
|
|
|
const screenshot = await page.screenshot({omitBackground: true, path: outputPath});
|
2020-10-07 01:51:18 +03:00
|
|
|
expect(await fs.promises.readFile(outputPath)).toMatchSnapshot('white.jpg');
|
|
|
|
expect(screenshot).toMatchSnapshot('white.jpg');
|
2020-08-28 23:53:47 +03:00
|
|
|
});
|
|
|
|
|
2020-09-19 01:52:14 +03:00
|
|
|
it('path option should throw for unsupported mime type', async ({page}) => {
|
2020-08-28 23:53:47 +03:00
|
|
|
const error = await page.screenshot({ path: 'file.txt' }).catch(e => e);
|
|
|
|
expect(error.message).toContain('path: unsupported mime type "text/plain"');
|
|
|
|
});
|
2020-10-11 07:50:37 +03:00
|
|
|
|
2020-12-23 20:53:14 +03:00
|
|
|
it('quality option should throw for png', async ({page}) => {
|
|
|
|
const error = await page.screenshot({ quality: 10 }).catch(e => e);
|
|
|
|
expect(error.message).toContain('options.quality is unsupported for the png');
|
|
|
|
});
|
|
|
|
|
|
|
|
it('zero quality option should throw for png', async ({page}) => {
|
|
|
|
const error = await page.screenshot({ quality: 0, type: 'png' }).catch(e => e);
|
|
|
|
expect(error.message).toContain('options.quality is unsupported for the png');
|
|
|
|
});
|
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('should prefer type over extension', async ({page}, testInfo) => {
|
2020-11-03 00:38:55 +03:00
|
|
|
const outputPath = testInfo.outputPath('file.png');
|
|
|
|
const buffer = await page.screenshot({ path: outputPath, type: 'jpeg' });
|
2020-10-27 10:02:35 +03:00
|
|
|
expect([buffer[0], buffer[1], buffer[2]]).toEqual([0xFF, 0xD8, 0xFF]);
|
|
|
|
});
|
|
|
|
|
2021-04-05 05:32:14 +03:00
|
|
|
it('should not issue resize event', async ({page, server}) => {
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
let resizeTriggered = false;
|
|
|
|
await page.exposeFunction('resize', () => {
|
|
|
|
resizeTriggered = true;
|
|
|
|
});
|
|
|
|
await page.evaluate(() => {
|
|
|
|
window.addEventListener('resize', () => (window as any).resize());
|
|
|
|
});
|
|
|
|
await page.screenshot();
|
|
|
|
expect(resizeTriggered).toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
browserTest.describe('page screenshot', () => {
|
|
|
|
browserTest.beforeEach(async ({ browserName, headful }) => {
|
|
|
|
browserTest.skip(browserName === 'firefox' && headful, 'Firefox headful produces a different image.');
|
|
|
|
browserTest.skip(!!process.env.PW_ANDROID_TESTS, 'Different viewport');
|
|
|
|
});
|
|
|
|
|
|
|
|
browserTest('should run in parallel in multiple pages', async ({server, contextFactory}) => {
|
|
|
|
const context = await contextFactory();
|
|
|
|
const N = 5;
|
|
|
|
const pages = await Promise.all(Array(N).fill(0).map(async () => {
|
|
|
|
const page = await context.newPage();
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
return page;
|
|
|
|
}));
|
|
|
|
const promises = [];
|
|
|
|
for (let i = 0; i < N; ++i)
|
|
|
|
promises.push(pages[i].screenshot({ clip: { x: 50 * (i % 2), y: 0, width: 50, height: 50 } }));
|
|
|
|
const screenshots = await Promise.all(promises);
|
|
|
|
for (let i = 0; i < N; ++i)
|
|
|
|
expect(screenshots[i]).toMatchSnapshot(`grid-cell-${i % 2}.png`);
|
|
|
|
await Promise.all(pages.map(page => page.close()));
|
|
|
|
});
|
|
|
|
|
|
|
|
browserTest('should work with a mobile viewport', async ({browser, server, browserName}) => {
|
|
|
|
browserTest.skip(browserName === 'firefox');
|
|
|
|
browserTest.fixme(browserName === 'chromium');
|
|
|
|
|
|
|
|
const context = await browser.newContext({ viewport: { width: 320, height: 480 }, isMobile: true });
|
|
|
|
const page = await context.newPage();
|
|
|
|
await page.goto(server.PREFIX + '/overflow.html');
|
|
|
|
const screenshot = await page.screenshot();
|
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-mobile.png');
|
|
|
|
await context.close();
|
|
|
|
});
|
|
|
|
|
|
|
|
browserTest('should work with a mobile viewport and clip', async ({browser, server, browserName}) => {
|
|
|
|
browserTest.skip(browserName === 'firefox');
|
|
|
|
browserTest.skip(process.env.CRPATH); // Does not work in stable Chrome.
|
|
|
|
|
|
|
|
const context = await browser.newContext({viewport: { width: 320, height: 480 }, isMobile: true});
|
|
|
|
const page = await context.newPage();
|
|
|
|
await page.goto(server.PREFIX + '/overflow.html');
|
|
|
|
const screenshot = await page.screenshot({ clip: { x: 10, y: 10, width: 100, height: 150 } });
|
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-mobile-clip.png');
|
|
|
|
await context.close();
|
|
|
|
});
|
|
|
|
|
|
|
|
browserTest('should work with a mobile viewport and fullPage', async ({browser, server, browserName}) => {
|
|
|
|
browserTest.skip(browserName === 'firefox');
|
|
|
|
|
|
|
|
const context = await browser.newContext({viewport: { width: 320, height: 480 }, isMobile: true});
|
|
|
|
const page = await context.newPage();
|
|
|
|
await page.goto(server.PREFIX + '/overflow-large.html');
|
|
|
|
const screenshot = await page.screenshot({ fullPage: true });
|
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-mobile-fullpage.png');
|
|
|
|
await context.close();
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
browserTest('should work with device scale factor', async ({browser, server}) => {
|
|
|
|
const context = await browser.newContext({ viewport: { width: 320, height: 480 }, deviceScaleFactor: 2 });
|
|
|
|
const page = await context.newPage();
|
|
|
|
await page.goto(server.PREFIX + '/grid.html');
|
|
|
|
const screenshot = await page.screenshot();
|
|
|
|
expect(screenshot).toMatchSnapshot('screenshot-device-scale-factor.png');
|
|
|
|
await context.close();
|
|
|
|
});
|
|
|
|
|
|
|
|
// Large screenshot is slow.
|
|
|
|
slowBrowserTest('should work with large size', async ({ browserName, headful, platform, contextFactory }) => {
|
|
|
|
slowBrowserTest.fixme(browserName === 'chromium' && headful === true && platform === 'linux', 'Chromium has gpu problems on linux with large screnshots');
|
|
|
|
|
|
|
|
const context = await contextFactory();
|
|
|
|
const page = await context.newPage();
|
|
|
|
|
2020-10-11 07:50:37 +03:00
|
|
|
await page.setViewportSize({ width: 1280, height: 800 });
|
|
|
|
await page.evaluate(() => {
|
|
|
|
document.body.style.margin = '0';
|
|
|
|
document.body.style.padding = '0';
|
|
|
|
document.documentElement.style.margin = '0';
|
|
|
|
document.documentElement.style.padding = '0';
|
|
|
|
const div = document.createElement('div');
|
|
|
|
div.style.width = '1250px';
|
|
|
|
div.style.height = '8440px';
|
|
|
|
div.style.background = 'linear-gradient(red, blue)';
|
|
|
|
document.body.appendChild(div);
|
|
|
|
});
|
|
|
|
const buffer = await page.screenshot({ fullPage: true });
|
|
|
|
const decoded = PNG.sync.read(buffer);
|
|
|
|
|
|
|
|
const pixel = (x: number, y: number) => {
|
|
|
|
const dst = new PNG({ width: 1, height: 1 });
|
|
|
|
PNG.bitblt(decoded, dst, x, y, 1, 1);
|
|
|
|
const pixels = dst.data;
|
|
|
|
return { r: pixels[0], g: pixels[1], b: pixels[2], a: pixels[3] };
|
|
|
|
};
|
|
|
|
|
|
|
|
expect(pixel(0, 0).r).toBeGreaterThan(128);
|
|
|
|
expect(pixel(0, 0).b).toBeLessThan(128);
|
|
|
|
expect(pixel(0, 8339).r).toBeLessThan(128);
|
|
|
|
expect(pixel(0, 8339).b).toBeGreaterThan(128);
|
|
|
|
});
|
2020-08-19 04:46:56 +03:00
|
|
|
});
|