1025 lines
31 KiB
PHP
1025 lines
31 KiB
PHP
<?php
|
|
|
|
use Zelda\EscposPhp\Printer;
|
|
use Zelda\EscposPhp\PrintConnectors\DummyPrintConnector;
|
|
use Zelda\EscposPhp\EscposImage;
|
|
use Zelda\EscposPhp\CapabilityProfile;
|
|
|
|
class EscposTest extends PHPUnit\Framework\TestCase
|
|
{
|
|
protected $printer;
|
|
protected $outputConnector;
|
|
|
|
protected function setUp(): void
|
|
{
|
|
/* Print to nowhere- for testing which inputs are accepted */
|
|
$this->outputConnector = new DummyPrintConnector();
|
|
$this->printer = new Printer($this->outputConnector);
|
|
}
|
|
|
|
protected function checkOutput($expected = null)
|
|
{
|
|
/* Check those output strings */
|
|
$outp = $this->outputConnector->getData();
|
|
if ($expected === null) {
|
|
echo "\nOutput was:\n\"" . friendlyBinary($outp) . "\"\n";
|
|
}
|
|
$this->assertEquals($expected, $outp);
|
|
}
|
|
|
|
protected function tearDown(): void
|
|
{
|
|
$this->outputConnector->finalize();
|
|
}
|
|
|
|
protected function requireGraphicsLibrary()
|
|
{
|
|
if (!EscposImage::isGdLoaded() && !EscposImage::isImagickLoaded()) {
|
|
// If the test is about to do something which requires a library,
|
|
// something must throw an exception.
|
|
$this->expectException(Exception::class);
|
|
}
|
|
}
|
|
|
|
public function testInitializeOutput()
|
|
{
|
|
$this->checkOutput("\x1b\x40");
|
|
}
|
|
|
|
public function testTextStringOutput()
|
|
{
|
|
$this->printer->text("The quick brown fox jumps over the lazy dog\n");
|
|
$this->checkOutput("\x1b@The quick brown fox jumps over the lazy dog\n");
|
|
}
|
|
|
|
public function testTextChinese()
|
|
{
|
|
// Switch to chinese print mode, GBK output, switch back to alphanumeric.
|
|
$this->printer->textChinese("示例文本打印机!\n");
|
|
$this->checkOutput("\x1b@\x1c&\xca\xbe\xc0\xfd\xce\xc4\xb1\xbe\xb4\xf2\xd3\xa1\xbb\xfa!\x0a\x1c.");
|
|
}
|
|
|
|
public function testTextRaw()
|
|
{
|
|
// Under raw output, the raw bytes are sent to the printer, so typing a UTF-8 euro literally causes \xE2 \x82 \xAC to be sent.
|
|
// Under text(), this would cause a code-page change (to a page that contains a Euro symbol), and single byte.
|
|
$this->printer->textRaw("€\n");
|
|
$this->checkOutput("\x1b@\xe2\x82\xac\x0a");
|
|
}
|
|
|
|
public function testTextString()
|
|
{
|
|
$this->printer->text("String");
|
|
$this->printer->text(123);
|
|
$this->printer->text(1.2);
|
|
$this->checkOutput("\x1b@String1231.2");
|
|
}
|
|
|
|
public function testFeedDefault()
|
|
{
|
|
$this->printer->feed();
|
|
$this->checkOutput("\x1b@\x0a");
|
|
}
|
|
|
|
public function testFeed3Lines()
|
|
{
|
|
$this->printer->feed(3);
|
|
$this->checkOutput("\x1b@\x1bd\x03");
|
|
}
|
|
|
|
public function testFeedZero()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->feed(0);
|
|
}
|
|
|
|
public function testFeedTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->feed(256);
|
|
}
|
|
|
|
/* Print mode */
|
|
public function testSelectPrintModeDefault()
|
|
{
|
|
$this->printer->selectPrintMode();
|
|
$this->checkOutput("\x1b@\x1b!\x00");
|
|
}
|
|
|
|
public function testSelectPrintModeAcceptedValues()
|
|
{
|
|
/* This iterates over a bunch of numbers, figures out which
|
|
ones contain invalid flags, and checks that the driver
|
|
rejects those, but accepts the good inputs */
|
|
|
|
for ($i = -1; $i <= 256; $i++) {
|
|
$invalid = ($i < 0) || ($i > 255) || (($i & 2) == 2) || (($i & 4) == 4) || (($i & 64) == 64);
|
|
$failed = false;
|
|
try {
|
|
$this->printer->selectPrintMode($i);
|
|
} catch (Exception $e) {
|
|
$failed = true;
|
|
}
|
|
$this->assertEquals($failed, $invalid);
|
|
}
|
|
}
|
|
|
|
/* Underline */
|
|
public function testSetUnderlineDefault()
|
|
{
|
|
$this->printer->setUnderline();
|
|
$this->checkOutput("\x1b@\x1b-\x01");
|
|
}
|
|
|
|
public function testSetUnderlineOff()
|
|
{
|
|
$this->printer->setUnderline(Printer::UNDERLINE_NONE);
|
|
$this->checkOutput("\x1b@\x1b-\x00");
|
|
}
|
|
|
|
public function testSetUnderlineOn()
|
|
{
|
|
$this->printer->setUnderline(Printer::UNDERLINE_SINGLE);
|
|
$this->checkOutput("\x1b@\x1b-\x01");
|
|
}
|
|
|
|
public function testSetUnderlineDbl()
|
|
{
|
|
$this->printer->setUnderline(Printer::UNDERLINE_DOUBLE);
|
|
$this->checkOutput("\x1b@\x1b-\x02");
|
|
}
|
|
|
|
public function testSetUnderlineAcceptedValues()
|
|
{
|
|
$this->printer->setUnderline(0);
|
|
$this->printer->setUnderline(1);
|
|
$this->printer->setUnderline(2);
|
|
/* These map to 0 & 1 for interchangeability with setEmphasis */
|
|
$this->printer->setUnderline(true);
|
|
$this->printer->setUnderline(false);
|
|
$this->checkOutput("\x1b@\x1b-\x00\x1b-\x01\x1b-\x02\x1b-\x01\x1b-\x00");
|
|
}
|
|
|
|
public function testSetUnderlineTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setUnderline(3);
|
|
}
|
|
|
|
public function testSetUnderlineNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setUnderline(-1);
|
|
}
|
|
|
|
/* Emphasis */
|
|
public function testSetEmphasisDefault()
|
|
{
|
|
$this->printer->setEmphasis();
|
|
$this->checkOutput("\x1b@\x1bE\x01");
|
|
}
|
|
|
|
public function testSetEmphasisOn()
|
|
{
|
|
$this->printer->setEmphasis(true);
|
|
$this->checkOutput("\x1b@\x1bE\x01");
|
|
}
|
|
|
|
public function testSetEmphasisOff()
|
|
{
|
|
$this->printer->setEmphasis(false);
|
|
$this->checkOutput("\x1b@\x1bE\x00");
|
|
}
|
|
|
|
/* Double strike */
|
|
public function testSetDoubleStrikeDefault()
|
|
{
|
|
$this->printer->setDoubleStrike();
|
|
$this->checkOutput("\x1b@\x1bG\x01");
|
|
}
|
|
|
|
public function testSetDoubleStrikeOn()
|
|
{
|
|
$this->printer->setDoubleStrike(true);
|
|
$this->checkOutput("\x1b@\x1bG\x01");
|
|
}
|
|
|
|
public function testSetDoubleStrikeOff()
|
|
{
|
|
$this->printer->setDoubleStrike(false);
|
|
$this->checkOutput("\x1b@\x1bG\x00");
|
|
}
|
|
|
|
/* Font */
|
|
public function testSetFontDefault()
|
|
{
|
|
$this->printer->setFont();
|
|
$this->checkOutput("\x1b@\x1bM\x00");
|
|
}
|
|
|
|
public function testSetFontAcceptedValues()
|
|
{
|
|
$this->printer->setFont(Printer::FONT_A);
|
|
$this->printer->setFont(Printer::FONT_B);
|
|
$this->printer->setFont(Printer::FONT_C);
|
|
$this->checkOutput("\x1b@\x1bM\x00\x1bM\x01\x1bM\x02");
|
|
}
|
|
|
|
public function testSetFontNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setFont(-1);
|
|
}
|
|
|
|
|
|
public function testSetFontTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setFont(3);
|
|
}
|
|
|
|
/* Justification */
|
|
public function testSetJustificationDefault()
|
|
{
|
|
$this->printer->setJustification();
|
|
$this->checkOutput("\x1b@\x1ba\x00");
|
|
}
|
|
|
|
public function testSetJustificationLeft()
|
|
{
|
|
$this->printer->setJustification(Printer::JUSTIFY_LEFT);
|
|
$this->checkOutput("\x1b@\x1ba\x00");
|
|
}
|
|
|
|
public function testSetJustificationRight()
|
|
{
|
|
$this->printer->setJustification(Printer::JUSTIFY_RIGHT);
|
|
$this->checkOutput("\x1b@\x1ba\x02");
|
|
}
|
|
|
|
public function testSetJustificationCenter()
|
|
{
|
|
$this->printer->setJustification(Printer::JUSTIFY_CENTER);
|
|
$this->checkOutput("\x1b@\x1ba\x01");
|
|
}
|
|
|
|
public function testSetJustificationNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setJustification(-1);
|
|
}
|
|
|
|
|
|
public function testSetJustificationTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setFont(3);
|
|
}
|
|
|
|
/* Reverse feed */
|
|
public function testFeedReverseDefault()
|
|
{
|
|
$this->printer->feedReverse();
|
|
$this->checkOutput("\x1b@\x1be\x01");
|
|
}
|
|
|
|
public function testFeedReverse3()
|
|
{
|
|
$this->printer->feedReverse(3);
|
|
$this->checkOutput("\x1b@\x1be\x03");
|
|
}
|
|
|
|
public function testFeedReverseNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->feedReverse(-1);
|
|
}
|
|
|
|
public function testFeedReverseTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->feedReverse(256);
|
|
}
|
|
|
|
/* Cut */
|
|
public function testCutDefault()
|
|
{
|
|
// TODO check what the accepted range of values should be for $line
|
|
// cut($mode = self::CUT_FULL, $lines = 3)
|
|
$this->printer->cut();
|
|
$this->checkOutput("\x1b@\x1dVA\x03");
|
|
}
|
|
|
|
/* Set barcode height */
|
|
public function testSetBarcodeHeightDefault()
|
|
{
|
|
$this->printer->setBarcodeHeight();
|
|
$this->checkOutput("\x1b@\x1dh\x08");
|
|
}
|
|
|
|
public function testBarcodeHeight10()
|
|
{
|
|
$this->printer->setBarcodeHeight(10);
|
|
$this->checkOutput("\x1b@\x1dh\x0a");
|
|
}
|
|
|
|
public function testSetBarcodeHeightNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeHeight(-1);
|
|
}
|
|
|
|
public function testSetBarcodeHeightTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeHeight(256);
|
|
}
|
|
|
|
/* Set barcode width */
|
|
public function testSetBarcodeWidthDefault()
|
|
{
|
|
$this->printer->setBarcodeWidth();
|
|
$this->checkOutput("\x1b@\x1dw\x03");
|
|
}
|
|
|
|
public function testBarcodeWidth1()
|
|
{
|
|
$this->printer->setBarcodeWidth(1);
|
|
$this->checkOutput("\x1b@\x1dw\x01");
|
|
}
|
|
|
|
public function testSetBarcodeWidthNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeWidth(-1);
|
|
}
|
|
|
|
public function testSetBarcodeWidthTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeWidth(256);
|
|
}
|
|
|
|
/* Barcode text position */
|
|
public function testSetBarcodeTextPositionDefault()
|
|
{
|
|
$this->printer->setBarcodeTextPosition();
|
|
$this->checkOutput("\x1b@\x1dH\x00");
|
|
}
|
|
|
|
public function testSetBarcodeTextPositionBelow()
|
|
{
|
|
$this->printer->setBarcodeTextPosition(Printer::BARCODE_TEXT_BELOW);
|
|
$this->checkOutput("\x1b@\x1dH\x02");
|
|
}
|
|
|
|
public function testSetBarcodeTextPositionBoth()
|
|
{
|
|
$this->printer->setBarcodeTextPosition(Printer::BARCODE_TEXT_BELOW | Printer::BARCODE_TEXT_ABOVE);
|
|
$this->checkOutput("\x1b@\x1dH\x03");
|
|
}
|
|
|
|
public function testSetBarcodeTextPositionNegative()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeTextPosition(-1);
|
|
}
|
|
|
|
public function testSetBarcodeTextPositionTooLarge()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeTextPosition(4);
|
|
}
|
|
|
|
public function tesSetBarcodeTextPositionNonInteger()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setBarcodeTextPosition('hello');
|
|
}
|
|
|
|
/* Barcode - UPC-A */
|
|
public function testBarcodeUpcaNumeric11Char()
|
|
{
|
|
$this->printer->barcode("01234567890", Printer::BARCODE_UPCA);
|
|
$this->checkOutput("\x1b@\x1dkA\x0b01234567890");
|
|
}
|
|
|
|
public function testBarcodeUpcaNumeric12Char()
|
|
{
|
|
$this->printer->barcode("012345678901", Printer::BARCODE_UPCA);
|
|
$this->checkOutput("\x1b@\x1dkA\x0c012345678901");
|
|
}
|
|
|
|
public function testBarcodeUpcaNumeric13Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("0123456789012", Printer::BARCODE_UPCA);
|
|
}
|
|
|
|
public function testBarcodeUpcaNonNumeric12Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("A12345678901", Printer::BARCODE_UPCA);
|
|
}
|
|
|
|
/* Barcode - UPC-E */
|
|
public function testBarcodeUpceNumeric6Char()
|
|
{
|
|
$this->printer->barcode("123456", Printer::BARCODE_UPCE);
|
|
$this->checkOutput("\x1b@\x1dkB\x06123456");
|
|
}
|
|
|
|
public function testBarcodeUpceNumeric7Char()
|
|
{
|
|
$this->printer->barcode("0123456", Printer::BARCODE_UPCE);
|
|
$this->checkOutput("\x1b@\x1dkB\x070123456");
|
|
}
|
|
|
|
public function testBarcodeUpceNumeric8Char()
|
|
{
|
|
$this->printer->barcode("01234567", Printer::BARCODE_UPCE);
|
|
$this->checkOutput("\x1b@\x1dkB\x0801234567");
|
|
}
|
|
|
|
public function testBarcodeUpceNumeric11Char()
|
|
{
|
|
$this->printer->barcode("01234567890", Printer::BARCODE_UPCE);
|
|
$this->checkOutput("\x1b@\x1dkB\x0b01234567890");
|
|
}
|
|
|
|
public function testBarcodeUpceNumeric12Char()
|
|
{
|
|
$this->printer->barcode("012345678901", Printer::BARCODE_UPCE);
|
|
$this->checkOutput("\x1b@\x1dkB\x0c012345678901");
|
|
}
|
|
|
|
public function testBarcodeUpceNumeric9Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("012345678", Printer::BARCODE_UPCE);
|
|
}
|
|
|
|
public function testBarcodeUpceNonNumeric12Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("A12345678901", Printer::BARCODE_UPCE);
|
|
}
|
|
|
|
/* Barcode - JAN13 */
|
|
public function testBarcodeJan13Numeric12Char()
|
|
{
|
|
$this->printer->barcode("012345678901", Printer::BARCODE_JAN13);
|
|
$this->checkOutput("\x1b@\x1dkC\x0c012345678901");
|
|
}
|
|
|
|
public function testBarcodeJan13Numeric13Char()
|
|
{
|
|
$this->printer->barcode("0123456789012", Printer::BARCODE_JAN13);
|
|
$this->checkOutput("\x1b@\x1dkC\x0d0123456789012");
|
|
}
|
|
|
|
public function testBarcodeJan13Numeric11Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("01234567890", Printer::BARCODE_JAN13);
|
|
}
|
|
|
|
public function testBarcodeJan13NonNumeric13Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("A123456789012", Printer::BARCODE_JAN13);
|
|
}
|
|
|
|
/* Barcode - JAN8 */
|
|
public function testBarcodeJan8Numeric7Char()
|
|
{
|
|
$this->printer->barcode("0123456", Printer::BARCODE_JAN8);
|
|
$this->checkOutput("\x1b@\x1dkD\x070123456");
|
|
}
|
|
|
|
public function testBarcodeJan8Numeric8Char()
|
|
{
|
|
$this->printer->barcode("01234567", Printer::BARCODE_JAN8);
|
|
$this->checkOutput("\x1b@\x1dkD\x0801234567");
|
|
}
|
|
|
|
public function testBarcodeJan8Numeric9Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("012345678", Printer::BARCODE_JAN8);
|
|
}
|
|
|
|
public function testBarcodeJan8NonNumeric8Char()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("A1234567", Printer::BARCODE_JAN8);
|
|
}
|
|
|
|
/* Barcode - Code39 */
|
|
public function testBarcodeCode39AsDefault()
|
|
{
|
|
$this->printer->barcode("1234");
|
|
$this->checkOutput("\x1b@\x1dkE\x041234");
|
|
}
|
|
|
|
public function testBarcodeCode39Text()
|
|
{
|
|
$this->printer->barcode("ABC 012", Printer::BARCODE_CODE39);
|
|
$this->checkOutput("\x1b@\x1dkE\x07ABC 012");
|
|
}
|
|
|
|
public function testBarcodeCode39SpecialChars()
|
|
{
|
|
$this->printer->barcode("$%+-./", Printer::BARCODE_CODE39);
|
|
$this->checkOutput("\x1b@\x1dkE\x06$%+-./");
|
|
}
|
|
|
|
public function testBarcodeCode39Asterisks()
|
|
{
|
|
$this->printer->barcode("*TEXT*", Printer::BARCODE_CODE39);
|
|
$this->checkOutput("\x1b@\x1dkE\x06*TEXT*");
|
|
}
|
|
|
|
public function testBarcodeCode39AsterisksUnmatched()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("*TEXT", Printer::BARCODE_CODE39);
|
|
}
|
|
|
|
public function testBarcodeCode39AsteriskInText()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("12*34", Printer::BARCODE_CODE39);
|
|
}
|
|
|
|
public function testBarcodeCode39Lowercase()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("abcd", Printer::BARCODE_CODE39);
|
|
}
|
|
|
|
public function testBarcodeCode39Empty()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("**", Printer::BARCODE_CODE39);
|
|
}
|
|
|
|
/* Barcode - ITF */
|
|
public function testBarcodeItfNumericEven()
|
|
{
|
|
$this->printer->barcode("1234", Printer::BARCODE_ITF);
|
|
$this->checkOutput("\x1b@\x1dkF\x041234");
|
|
}
|
|
|
|
public function testBarcodeItfNumericOdd()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("123", Printer::BARCODE_ITF);
|
|
}
|
|
|
|
public function testBarcodeItfNonNumericEven()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("A234", Printer::BARCODE_ITF);
|
|
}
|
|
|
|
/* Barcode - Codabar */
|
|
public function testBarcodeCodabarNumeric()
|
|
{
|
|
$this->printer->barcode("A012345A", Printer::BARCODE_CODABAR);
|
|
$this->checkOutput("\x1b@\x1dkG\x08A012345A");
|
|
}
|
|
|
|
public function testBarcodeCodabarSpecialChars()
|
|
{
|
|
$this->printer->barcode("A012$+-./:A", Printer::BARCODE_CODABAR);
|
|
$this->checkOutput("\x1b@\x1dkG\x0bA012$+-./:A");
|
|
}
|
|
|
|
public function testBarcodeCodabarNotWrapped()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("012345", Printer::BARCODE_CODABAR);
|
|
}
|
|
|
|
public function testBarcodeCodabarStartStopWrongPlace()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("012A45", Printer::BARCODE_CODABAR);
|
|
}
|
|
|
|
/* Barcode - Code93 */
|
|
public function testBarcodeCode93Valid()
|
|
{
|
|
$this->printer->barcode("012abcd", Printer::BARCODE_CODE93);
|
|
$this->checkOutput("\x1b@\x1dkH\x07012abcd");
|
|
}
|
|
|
|
public function testBarcodeCode93Empty()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("", Printer::BARCODE_CODE93);
|
|
}
|
|
|
|
/* Barcode - Code128 */
|
|
public function testBarcodeCode128ValidA()
|
|
{
|
|
$this->printer->barcode("{A" . "012ABCD", Printer::BARCODE_CODE128);
|
|
$this->checkOutput("\x1b@\x1dkI\x09{A012ABCD");
|
|
}
|
|
|
|
public function testBarcodeCode128ValidB()
|
|
{
|
|
$this->printer->barcode("{B" . "012ABCDabcd", Printer::BARCODE_CODE128);
|
|
$this->checkOutput("\x1b@\x1dkI\x0d{B012ABCDabcd");
|
|
}
|
|
|
|
public function testBarcodeCode128ValidC()
|
|
{
|
|
$this->printer->barcode("{C" . chr(21) . chr(32) . chr(43), Printer::BARCODE_CODE128);
|
|
$this->checkOutput("\x1b@\x1dkI\x05{C\x15 +");
|
|
}
|
|
|
|
public function testBarcodeCode128NoCodeSet()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->barcode("ABCD", Printer::BARCODE_CODE128);
|
|
}
|
|
|
|
/* Pulse */
|
|
function testPulseDefault()
|
|
{
|
|
$this->printer->pulse();
|
|
$this->checkOutput("\x1b@\x1bp0<x");
|
|
}
|
|
|
|
function testPulse1()
|
|
{
|
|
$this->printer->pulse(1);
|
|
$this->checkOutput("\x1b@\x1bp1<x");
|
|
}
|
|
|
|
function testPulseEvenMs()
|
|
{
|
|
$this->printer->pulse(0, 2, 2);
|
|
$this->checkOutput("\x1b@\x1bp0\x01\x01");
|
|
}
|
|
|
|
function testPulseOddMs()
|
|
{
|
|
$this->printer->pulse(0, 3, 3); // Should be rounded down and give same output
|
|
$this->checkOutput("\x1b@\x1bp0\x01\x01");
|
|
}
|
|
|
|
function testPulseTooHigh()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->pulse(0, 512, 2);
|
|
}
|
|
|
|
function testPulseTooLow()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->pulse(0, 0, 2);
|
|
}
|
|
|
|
/* Set reverse */
|
|
public function testSetReverseColorsDefault()
|
|
{
|
|
$this->printer->setReverseColors();
|
|
$this->checkOutput("\x1b@\x1dB\x01");
|
|
}
|
|
|
|
public function testSetReverseColorsOn()
|
|
{
|
|
$this->printer->setReverseColors(true);
|
|
$this->checkOutput("\x1b@\x1dB\x01");
|
|
}
|
|
|
|
public function testSetReverseColorsOff()
|
|
{
|
|
$this->printer->setReverseColors(false);
|
|
$this->checkOutput("\x1b@\x1dB\x00");
|
|
}
|
|
|
|
/* Bit image print */
|
|
public function testBitImageBlack()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_black.png");
|
|
$this->printer->bitImage($img);
|
|
$this->checkOutput("\x1b@\x1dv0\x00\x01\x00\x01\x00\x80");
|
|
}
|
|
|
|
public function testBitImageWhite()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_white.png");
|
|
$this->printer->bitImage($img);
|
|
$this->checkOutput("\x1b@\x1dv0\x00\x01\x00\x01\x00\x00");
|
|
}
|
|
|
|
public function testBitImageBoth()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_white.png");
|
|
$this->printer->bitImage($img);
|
|
$this->checkOutput("\x1b@\x1dv0\x00\x01\x00\x02\x00\xc0\x00");
|
|
}
|
|
|
|
public function testBitImageTransparent()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_transparent.png");
|
|
$this->printer->bitImage($img);
|
|
$this->checkOutput("\x1b@\x1dv0\x00\x01\x00\x02\x00\xc0\x00");
|
|
}
|
|
|
|
/* Bit image column format */
|
|
public function testBitImageColumnFormatBlack()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_black.png");
|
|
$this->printer->bitImageColumnFormat($img);
|
|
$this->checkOutput("\x1b@\x1b3\x10\x1b*!\x01\x00\x80\x00\x00\x0a\x1b2");
|
|
}
|
|
|
|
public function testBitImageColumnFormatWhite()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_white.png");
|
|
$this->printer->bitImageColumnFormat($img);
|
|
$this->checkOutput("\x1b@\x1b3\x10\x1b*!\x01\x00\x00\x00\x00\x0a\x1b2");
|
|
}
|
|
|
|
public function testBitImageColumnFormatBoth()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_white.png");
|
|
$this->printer->bitImageColumnFormat($img);
|
|
$this->checkOutput("\x1b@\x1b3\x10\x1b*!\x02\x00\x80\x00\x00\x80\x00\x00\x0a\x1b2");
|
|
}
|
|
|
|
public function testBitImageColumnFormatTransparent()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_transparent.png");
|
|
$this->printer->bitImageColumnFormat($img);
|
|
$this->checkOutput("\x1b@\x1b3\x10\x1b*!\x02\x00\x80\x00\x00\x80\x00\x00\x0a\x1b2");
|
|
}
|
|
|
|
/* Graphics print */
|
|
public function testGraphicsWhite()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_white.png");
|
|
$this->printer->graphics($img);
|
|
$this->checkOutput("\x1b@\x1d(L\x0b\x000p0\x01\x011\x01\x00\x01\x00\x00\x1d(L\x02\x0002");
|
|
}
|
|
|
|
public function testGraphicsBlack()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/canvas_black.png");
|
|
$this->printer->graphics($img);
|
|
$this->checkOutput("\x1b@\x1d(L\x0b\x000p0\x01\x011\x01\x00\x01\x00\x80\x1d(L\x02\x0002");
|
|
}
|
|
|
|
public function testGraphicsBoth()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_white.png");
|
|
$this->printer->graphics($img);
|
|
$this->checkOutput("\x1b@\x1d(L\x0c\x000p0\x01\x011\x02\x00\x02\x00\xc0\x00\x1d(L\x02\x0002");
|
|
}
|
|
|
|
public function testGraphicsTransparent()
|
|
{
|
|
$this->requireGraphicsLibrary();
|
|
$img = EscposImage::load(dirname(__FILE__) . "/resources/black_transparent.png");
|
|
$this->printer->graphics($img);
|
|
$this->checkOutput("\x1b@\x1d(L\x0c\x000p0\x01\x011\x02\x00\x02\x00\xc0\x00\x1d(L\x02\x0002");
|
|
}
|
|
|
|
/* PDF417 code */
|
|
public function testPdf417CodeDefaults()
|
|
{
|
|
$this->printer->pdf417Code("1234");
|
|
$this->checkOutput("\x1b@\x1d(k\x03\x000F\x00\x1d(k\x03\x000A\x00\x1d(k\x03\x000C\x03\x1d(k\x03\x000D\x03\x1d(k\x04\x000E1\x01\x1d(k\x07\x000P01234\x1d(k\x03\x000Q0");
|
|
}
|
|
|
|
public function testPdf417CodeEmpty()
|
|
{
|
|
$this->printer->pdf417Code('');
|
|
$this->checkOutput("\x1b@"); // No commands actually sent
|
|
}
|
|
|
|
public function testPdf417CodeNotSupported()
|
|
{
|
|
$this->expectException(Exception::class);
|
|
$profile = CapabilityProfile::load("simple");
|
|
$this->printer = new Printer($this->outputConnector, $profile);
|
|
$this->printer->pdf417Code("1234");
|
|
}
|
|
|
|
public function testPdf417CodeChangeGeometry()
|
|
{
|
|
// 7-dot wide, 4-times height, 4 data columns
|
|
$this->printer->pdf417Code("1234", 7, 4, 4);
|
|
$this->checkOutput("\x1b@\x1d(k\x03\x000F\x00\x1d(k\x03\x000A\x04\x1d(k\x03\x000C\x07\x1d(k\x03\x000D\x04\x1d(k\x04\x000E1\x01\x1d(k\x07\x000P01234\x1d(k\x03\x000Q0");
|
|
}
|
|
|
|
public function testPdf417CodeChangeErrorCorrection()
|
|
{
|
|
$this->printer->pdf417Code("1234", 3, 3, 0, 0.5);
|
|
$this->checkOutput("\x1b@\x1d(k\x03\x000F\x00\x1d(k\x03\x000A\x00\x1d(k\x03\x000C\x03\x1d(k\x03\x000D\x03\x1d(k\x04\x000E1\x05\x1d(k\x07\x000P01234\x1d(k\x03\x000Q0");
|
|
}
|
|
|
|
public function testPdf417CodeChangeErrorCorrectionOutOfRange()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->pdf417Code("1234", 3, 3, 0, 5.0);
|
|
}
|
|
|
|
public function testPdf417CodeChangeOption()
|
|
{
|
|
// Use the alternate truncated format
|
|
$this->printer->pdf417Code("1234", 3, 3, 0, 0.1, Printer::PDF417_TRUNCATED);
|
|
$this->checkOutput("\x1b@\x1d(k\x03\x000F\x01\x1d(k\x03\x000A\x00\x1d(k\x03\x000C\x03\x1d(k\x03\x000D\x03\x1d(k\x04\x000E1\x01\x1d(k\x07\x000P01234\x1d(k\x03\x000Q0");
|
|
}
|
|
|
|
/* QR code */
|
|
public function testQRCodeDefaults()
|
|
{
|
|
// Test will fail if default values change
|
|
$this->printer->qrCode("1234");
|
|
$this->checkOutput("\x1b@\x1d(k\x04\x001A2\x00\x1d(k\x03\x001C\x03\x1d(k\x03\x001E0\x1d(k\x07\x001P01234\x1d(k\x03\x001Q0");
|
|
}
|
|
|
|
public function testQRCodeDefaultsAreCorrect()
|
|
{
|
|
// Below tests assume that defaults are as written here (output string should be same as above)
|
|
$this->printer->qrCode("1234", Printer::QR_ECLEVEL_L, 3, Printer::QR_MODEL_2);
|
|
$this->checkOutput("\x1b@\x1d(k\x04\x001A2\x00\x1d(k\x03\x001C\x03\x1d(k\x03\x001E0\x1d(k\x07\x001P01234\x1d(k\x03\x001Q0");
|
|
}
|
|
|
|
public function testQRCodeEmpty()
|
|
{
|
|
$this->printer->qrCode('');
|
|
$this->checkOutput("\x1b@"); // No commands actually sent
|
|
}
|
|
|
|
public function testQRCodeChangeEC()
|
|
{
|
|
$this->printer->qrCode("1234", Printer::QR_ECLEVEL_H);
|
|
$this->checkOutput("\x1b@\x1d(k\x04\x001A2\x00\x1d(k\x03\x001C\x03\x1d(k\x03\x001E3\x1d(k\x07\x001P01234\x1d(k\x03\x001Q0");
|
|
}
|
|
|
|
public function testQRCodeChangeSize()
|
|
{
|
|
$this->printer->qrCode("1234", Printer::QR_ECLEVEL_L, 7);
|
|
$this->checkOutput("\x1b@\x1d(k\x04\x001A2\x00\x1d(k\x03\x001C\x07\x1d(k\x03\x001E0\x1d(k\x07\x001P01234\x1d(k\x03\x001Q0");
|
|
}
|
|
|
|
public function testQRCodeChangeModel()
|
|
{
|
|
$this->printer->qrCode("1234", Printer::QR_ECLEVEL_L, 3, Printer::QR_MODEL_1);
|
|
$this->checkOutput("\x1b@\x1d(k\x04\x001A1\x00\x1d(k\x03\x001C\x03\x1d(k\x03\x001E0\x1d(k\x07\x001P01234\x1d(k\x03\x001Q0");
|
|
}
|
|
|
|
/* Feed form - Required on page-mode only printers */
|
|
public function testFeedForm()
|
|
{
|
|
$this->printer->feedForm();
|
|
$this->checkOutput("\x1b@\x0c");
|
|
}
|
|
|
|
/* Release */
|
|
public function testRelease()
|
|
{
|
|
$this->printer->release();
|
|
$this->checkOutput("\x1b@\x1b\x71");
|
|
}
|
|
|
|
/* Set text size */
|
|
public function testSetTextSizeNormal()
|
|
{
|
|
$this->printer->setTextSize(1, 1);
|
|
$this->checkOutput("\x1b@\x1d!\x00");
|
|
}
|
|
|
|
public function testSetTextSizeWide()
|
|
{
|
|
$this->printer->setTextSize(4, 1);
|
|
$this->checkOutput("\x1b@\x1d!0");
|
|
}
|
|
|
|
public function testSetTextSizeNarrow()
|
|
{
|
|
$this->printer->setTextSize(1, 4);
|
|
$this->checkOutput("\x1b@\x1d!\x03");
|
|
}
|
|
|
|
public function testSetTextSizeLarge()
|
|
{
|
|
$this->printer->setTextSize(4, 4);
|
|
$this->checkOutput("\x1b@\x1d!3");
|
|
}
|
|
|
|
public function testSetTextSizeInvalid()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setTextSize(0, 9);
|
|
}
|
|
|
|
/* Set color */
|
|
public function testSetColorDefault()
|
|
{
|
|
$this->printer->setColor(Printer::COLOR_1);
|
|
$this->checkOutput("\x1b@\x1br\x00");
|
|
}
|
|
|
|
public function testSetColorAlternative()
|
|
{
|
|
$this->printer->setColor(Printer::COLOR_2);
|
|
$this->checkOutput("\x1b@\x1br\x01");
|
|
}
|
|
|
|
public function testSetColorInvalid()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setColor(3);
|
|
}
|
|
|
|
/* Set line spacing */
|
|
public function testSetLineSpacingDefault()
|
|
{
|
|
$this->printer->setLineSpacing();
|
|
$this->checkOutput("\x1b@\x1b2");
|
|
}
|
|
|
|
public function testSetLineSpacingInvalid()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setLineSpacing(300);
|
|
}
|
|
|
|
public function testSetLineSpacingSmaller()
|
|
{
|
|
$this->printer->setLineSpacing(16);
|
|
$this->checkOutput("\x1b@\x1b3\x10");
|
|
}
|
|
|
|
public function testSetLineSpacingLarger()
|
|
{
|
|
$this->printer->setLineSpacing(32);
|
|
$this->checkOutput("\x1b@\x1b3\x20");
|
|
}
|
|
|
|
/* Set print width */
|
|
public function testSetPrintWidthDefault()
|
|
{
|
|
$this->printer->setPrintWidth();
|
|
$this->checkOutput("\x1b@\x1dW\x00\x02");
|
|
}
|
|
|
|
public function testSetPrintWidthNarrow()
|
|
{
|
|
$this->printer->setPrintWidth(400);
|
|
$this->checkOutput("\x1b@\x1dW\x90\x01");
|
|
}
|
|
|
|
public function testSetPrintWidthInvalid()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setPrintWidth(0);
|
|
}
|
|
|
|
/* Set print left margin */
|
|
public function testSetPrintLeftMarginDefault()
|
|
{
|
|
$this->printer->setPrintLeftMargin();
|
|
$this->checkOutput("\x1b@\x1dL\x00\x00");
|
|
}
|
|
|
|
public function testSetPrintLeftMarginWide()
|
|
{
|
|
$this->printer->setPrintLeftMargin(32);
|
|
$this->checkOutput("\x1b@\x1dL\x20\x00");
|
|
}
|
|
|
|
public function testPrintLeftMarginInvalid()
|
|
{
|
|
$this->expectException(InvalidArgumentException::class);
|
|
$this->printer->setPrintLeftMargin(70000);
|
|
$this->checkOutput();
|
|
}
|
|
|
|
/* Upside-down print */
|
|
public function testSetUpsideDown()
|
|
{
|
|
$this->printer->setUpsideDown(true);
|
|
$this->checkOutput("\x1b@\x1b{\x01");
|
|
}
|
|
}
|