| // This may look like C code, but it is really -*- C++ -*- |
| // |
| // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003 |
| // |
| // Tests for setting/getting Magick::Image attributes |
| // |
| |
| #include <Magick++.h> |
| #include <string> |
| #include <iostream> |
| |
| using namespace std; |
| |
| using namespace Magick; |
| |
| int main( int /*argc*/, char ** argv) |
| { |
| |
| // Initialize ImageMagick install location for Windows |
| InitializeMagick(*argv); |
| |
| volatile int failures=0; |
| |
| try { |
| |
| size_t columns = 640; |
| size_t rows = 480; |
| Geometry geometry(columns,rows); |
| Color canvasColor( "red" ); |
| Image image( geometry, canvasColor); |
| |
| // |
| // antiAlias |
| // |
| |
| // Test default value |
| if ( image.textAntiAlias() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", textAntiAlias default not true" << endl; |
| } |
| |
| // Test setting false |
| image.textAntiAlias( false ); |
| if ( image.textAntiAlias() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", textAntiAlias not false" << endl; |
| } |
| |
| // Test setting true |
| image.textAntiAlias( true ); |
| if ( image.textAntiAlias() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", textAntiAlias not true" << endl; |
| } |
| |
| // |
| // adjoin |
| // |
| |
| // Test default value |
| if ( image.adjoin() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", adjoin default not 'true' as expected" << endl; |
| } |
| |
| // Test setting false |
| image.adjoin( false ); |
| if ( image.adjoin() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", adjoin failed set to 'false'" << endl; |
| } |
| |
| // Test setting true |
| image.adjoin( true ); |
| if ( image.adjoin() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", adjoin failed set to 'true'" << endl; |
| } |
| |
| // |
| // animationDelay |
| // |
| |
| // Test default value |
| if ( image.animationDelay() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", animationDelay default (" |
| << image.animationDelay() |
| << ") not 0 as expected" << endl; |
| } |
| |
| // Test setting to 0 |
| image.animationDelay( 0 ); |
| if ( image.animationDelay() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set animationDelay to 0" << endl; |
| } |
| |
| // Test setting to 100 |
| image.animationDelay( 100 ); |
| if ( image.animationDelay() != 100 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set animationDelay to 100" << endl; |
| } |
| image.animationDelay(0); |
| |
| // |
| // animationIterations |
| // |
| |
| // Test default value |
| if ( image.animationIterations() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", animationIterations default (" |
| << image.animationIterations() |
| << ") not 0 as expected" << endl; |
| } |
| |
| // Test setting to 0 |
| image.animationIterations( 0 ); |
| if ( image.animationIterations() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set animationIterations to 0" << endl; |
| } |
| |
| // Test setting to 100 |
| image.animationIterations( 100 ); |
| if ( image.animationIterations() != 100 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set animationIterations to 100" << endl; |
| } |
| image.animationIterations( 0 ); |
| |
| // |
| // backgroundColor |
| // |
| |
| // Test default value. |
| if ( string(image.backgroundColor()) != string(ColorRGB("white")) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundColor default (" |
| << string(image.backgroundColor()) |
| << ") is incorrect" << endl; |
| } |
| |
| // Test setting to blue |
| image.backgroundColor("blue"); |
| if ( !image.backgroundColor().isValid() ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundColor (" |
| << string(image.backgroundColor()) |
| << ") failed set to 'blue'" << endl; |
| } |
| else |
| if ( string(image.backgroundColor()) != "#0000FF" && |
| string(image.backgroundColor()) != "#00000000FFFF" && |
| string(image.backgroundColor()) != "#0000000000000000FFFFFFFF" && |
| string(image.backgroundColor()) != "#00000000000000000000000000000000FFFFFFFFFFFFFFFF" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundColor (" |
| << string(image.backgroundColor()) << ") is incorrect" |
| << endl; |
| } |
| |
| // Test setting using hex color |
| image.backgroundColor("#00AAFF"); |
| if ( !image.backgroundColor().isValid() ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundColor (" |
| << string(image.backgroundColor()) |
| << ") is incorrectly invalid" << endl; |
| } |
| else |
| if ( string(image.backgroundColor()) != "#00AAFF" && |
| string(image.backgroundColor()) != "#0000AAAAFFFF" && |
| string(image.backgroundColor()) != "#00000000AAAAAAAAFFFFFFFF" && |
| string(image.backgroundColor()) != "#0000000000000000AAAAAAAAAAAAAAAAFFFFFFFFFFFFFFFF" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", backgroundColor (" |
| << string(image.backgroundColor()) |
| << ") is incorrect" |
| << endl; |
| } |
| |
| // |
| // backgroundTexture |
| // |
| |
| // Test default value |
| if ( image.backgroundTexture() != "" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundTexture default (" |
| << image.backgroundTexture() |
| << ") is incorrect" << endl; |
| } |
| |
| // Test setting/getting value |
| image.backgroundTexture("afile.jpg"); |
| if ( image.backgroundTexture() != "afile.jpg" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", backgroundTexture (" |
| << image.backgroundTexture() |
| << ") is incorrect" << endl; |
| } |
| |
| // Test setting back to default |
| image.backgroundTexture(""); |
| if ( image.backgroundTexture() != "" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", backgroundTexture (" |
| << image.backgroundTexture() |
| << ") failed to set to \"\"" << endl; |
| } |
| |
| // |
| // baseColumns |
| // |
| if ( image.baseColumns() != columns ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", baseColumns (" |
| << image.baseColumns() |
| << ") is not equal to " |
| << columns |
| << " as expected" |
| << endl; |
| } |
| |
| |
| // |
| // baseFilename |
| // |
| // Base filename is color for xc images |
| if ( image.baseFilename() != "xc:#FF0000" && |
| image.baseFilename() != "xc:#FFFF00000000" && |
| image.baseFilename() != "xc:#FFFFFFFF0000000000000000" && |
| image.baseFilename() != "xc:#FFFFFFFFFFFFFFFF00000000000000000000000000000000") |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", baseFilename (" |
| << image.baseFilename() |
| << ") is incorrect" |
| << endl; |
| } |
| |
| // |
| // baseRows |
| // |
| if ( image.baseRows() != rows ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", baseRows (" |
| << image.baseRows() |
| << ") != rows (" |
| << rows |
| << ")" |
| << endl; |
| } |
| |
| // |
| // borderColor |
| // |
| if ( image.borderColor() != ColorRGB("#dfdfdf") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", borderColor default (" |
| << string(image.borderColor()) |
| << ") is incorrect" << endl; |
| } |
| |
| image.borderColor("#FF0000"); |
| if ( image.borderColor() != Color("#FF0000") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set borderColor (" |
| << string(image.borderColor()) |
| << ")" << endl; |
| } |
| |
| image.borderColor("black"); |
| if ( image.borderColor() != Color("#000000") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set borderColor (" |
| << string(image.borderColor()) |
| << ")" |
| << endl; |
| } |
| |
| // |
| // boxColor |
| // |
| image.boxColor("#FF0000"); |
| if ( image.boxColor() != Color("#FF0000") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set boxColor (" |
| << string(image.boxColor()) |
| << ")" |
| << endl; |
| } |
| |
| image.boxColor("black"); |
| if ( image.boxColor() != Color("#000000") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", failed to set boxColor (" |
| << string(image.boxColor()) |
| << ") to #000000" |
| << endl; |
| } |
| |
| // |
| // chromaBluePrimary |
| // |
| { |
| // Test default setting |
| double x, y, z; |
| image.chromaBluePrimary(&x, &y, &z); |
| if ( x == 0.0f || y == 0.0f ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaBluePrimary x/y defaults are zero" |
| << endl; |
| } |
| |
| // Test set/get |
| image.chromaBluePrimary(50, 100, 150 ); |
| image.chromaBluePrimary(&x, &y, &z); |
| if ( x != 50 || y != 100 || z != 150 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaBluePrimary x/y failed set/get" << endl; |
| } |
| } |
| |
| // |
| // chromaGreenPrimary |
| // |
| { |
| // Test default setting |
| double x, y, z; |
| image.chromaGreenPrimary(&x, &y, &z); |
| if ( x == 0.0f || y == 0.0f ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaGreenPrimary x/y defaults are zero" << endl; |
| } |
| |
| // Test set/get |
| image.chromaGreenPrimary(50, 100, 150); |
| image.chromaGreenPrimary(&x, &y, &z); |
| if (x != 50 || y != 100 || z != 150) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaGreenPrimary x/y failed set/get" << endl; |
| } |
| } |
| |
| // |
| // chromaRedPrimary |
| // |
| { |
| // Test default setting |
| double x, y, z; |
| image.chromaRedPrimary(&x, &y, &z); |
| if ( x == 0.0f || y == 0.0f ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaRedPrimary x/y defaults are zero" << endl; |
| } |
| |
| // Test set/get |
| image.chromaRedPrimary(50, 100, 150); |
| image.chromaRedPrimary(&x, &y, &z); |
| if (x != 50 || y != 100 || z != 150) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaRedPrimary x/y failed set/get" << endl; |
| } |
| } |
| |
| // |
| // chromaWhitePoint |
| // |
| { |
| // Test default setting |
| double x, y, z; |
| image.chromaWhitePoint(&x, &y, &z); |
| if ( x == 0.0f || y == 0.0f ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaWhitePoint x/y defaults are zero" << endl; |
| } |
| |
| // Test set/get |
| image.chromaWhitePoint(50, 100, 150); |
| image.chromaWhitePoint(&x, &y, &z); |
| if (x != 50 || y != 100 || z != 150) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", chromaWhitePoint x/y failed set/get" << endl; |
| } |
| } |
| |
| // |
| // classType |
| // |
| if ( image.classType() != DirectClass ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", classType is not DirectClass" << endl; |
| } |
| |
| // |
| // colorFuzz |
| // |
| |
| // Test default |
| if ( image.colorFuzz() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", colorFuzz default is non-zero" << endl; |
| } |
| |
| // Test set/get |
| image.colorFuzz( 2 ); |
| if ( image.colorFuzz() != 2 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", colorFuzz failed to set/get" << endl; |
| } |
| image.colorFuzz( 0 ); |
| |
| // |
| // columns |
| // |
| if ( image.columns() != columns ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", columns is not equal to canvas image columns" << endl; |
| } |
| |
| // |
| // comment |
| // |
| // Test default |
| if ( image.comment().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", comment default non-zero length" << endl; |
| } |
| |
| // Test set/get |
| { |
| std::string comment("This is a comment."); |
| image.comment( comment ); |
| if ( image.comment() != comment ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", comment set/get failed" << endl; |
| } |
| } |
| |
| // Test resetting comment |
| image.comment( string() ); |
| if ( image.comment().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", comment failed to reset" << endl; |
| } |
| |
| // |
| // compressType |
| // |
| // Test default |
| if ( image.compressType() != UndefinedCompression ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", compressType default is incorrect" << endl; |
| } |
| |
| // Test set/get |
| image.compressType(RLECompression); |
| if ( image.compressType() != RLECompression ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", compressType set/get failed" << endl; |
| } |
| image.compressType(UndefinedCompression); |
| |
| // |
| // density |
| // |
| { |
| // Test defaults |
| if ( image.density() != Point(72) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", density default is not 72x72 as expected" << endl; |
| } |
| |
| // Test set/get |
| Point density(150,75); |
| image.density(density); |
| if ( image.density() != density ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", density set/get failed" << endl; |
| } |
| |
| |
| if ( image.xResolution() != 150 || |
| image.yResolution() != 75 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", density set/get failed" << endl; |
| } |
| |
| image.density("72x72"); |
| |
| } |
| |
| // |
| // Format specific defines |
| // |
| if (image.defineSet("foo","bar")) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", define for foo:bar incorrectly reports set." |
| << endl; |
| } |
| |
| image.defineSet("foo","bar",true); |
| if (!image.defineSet("foo","bar")) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", define for foo:bar incorrectly reports not set." |
| << endl; |
| } |
| |
| image.defineSet("foo","bar",false); |
| if (image.defineSet("foo","bar")) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", define for foo:bar incorrectly reports set." |
| << endl; |
| } |
| |
| image.defineValue("foo","bar","value"); |
| std::string value = image.defineValue("foo","bar"); |
| if (image.defineValue("foo","bar") != "value") |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", define for foo:bar incorrectly reports value \"" |
| << value << "\"" |
| << endl; |
| } |
| |
| image.defineSet("foo","bar",false); |
| if (image.defineSet("foo","bar")) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", define for foo:bar incorrectly reports set." |
| << endl; |
| } |
| |
| // |
| // depth |
| // |
| if ( image.depth() != MAGICKCORE_QUANTUM_DEPTH ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", depth (" |
| << image.depth() |
| << ") is not equal to " << MAGICKCORE_QUANTUM_DEPTH << endl; |
| } |
| |
| // |
| // Directory |
| // |
| { |
| // Since this is not a montage image, simply verify error report |
| bool caughtException = false; |
| cout << "Testing throwing and catching exceptions. A program crash or a message" << endl |
| << "that the exception was not caught indicates a test failure. A properly" << endl |
| << "formatted exception message indicates success:" << endl; |
| try |
| { |
| //image.directory(); |
| Magick::Image bad_image("foo"); |
| } |
| catch ( Exception &exception_) |
| { |
| cout << "Caught exception, good!:" << endl |
| << " \"" << exception_.what() << "\"" << endl; |
| caughtException = true; |
| } |
| if ( caughtException != true ) |
| { |
| ++failures; |
| cout << "failed to catch exception!" << endl; |
| } |
| } |
| |
| // |
| // fileName |
| // |
| // Test default |
| if ( image.fileName() != string("xc:") + string(canvasColor) ) |
| { |
| ++failures; |
| cout << "Line: " |
| << __LINE__ |
| << ", fileName (" |
| << image.fileName() |
| << ") is not canvas color (" |
| << string(canvasColor) |
| <<") as expected" << endl; |
| } |
| |
| // Set/get value |
| image.fileName("filename.jpg"); |
| if ( image.fileName() != "filename.jpg" ) |
| { |
| ++failures; |
| cout << "Line: " |
| << __LINE__ |
| << ", fileName (" |
| << image.fileName() |
| << ") failed to set/get" << endl; |
| } |
| image.fileName(canvasColor); |
| |
| // |
| // fileSize |
| // |
| // Test default |
| if ( image.fileSize() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", fileSize (" |
| << static_cast<ssize_t>(image.fileSize()) |
| << ") is not zero as expected" << endl; |
| } |
| |
| // |
| // filterType |
| // |
| // Test default |
| if ( image.filterType() != UndefinedFilter ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", filterType default (" |
| << (int)image.filterType() |
| << ") is incorrect" << endl; |
| } |
| |
| // Test set/get |
| image.filterType( TriangleFilter ); |
| if ( image.filterType() != TriangleFilter ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", filterType set/get failed" |
| << endl; |
| } |
| |
| // |
| // font |
| // |
| |
| // Test set/get |
| image.font("helvetica"); |
| if ( image.font() != "helvetica" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", font set/get failed" << endl; |
| } |
| // Test set to null font |
| image.font( string() ); |
| if ( image.font().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", font failed to unset" << endl; |
| } |
| |
| // |
| // fontPointsize |
| // |
| // Test default |
| if ( image.fontPointsize() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", fontPointsize (" |
| << image.fontPointsize() |
| << ") is not default of 0 as expected" |
| << endl; |
| } |
| |
| // Test set/get |
| image.fontPointsize(10); |
| if ( image.fontPointsize() != 10 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", fontPointsize set/get failed" << endl; |
| } |
| image.fontPointsize(12); |
| |
| // |
| // format |
| // |
| if ( image.format() != "Constant image uniform color" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", format (" << image.format() << ") is not expected value" << endl; |
| } |
| |
| // |
| // gamma |
| // |
| if ( image.gamma() == 1.0f) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", gamma correction is unity as expected" << endl; |
| } |
| |
| // |
| // geometry |
| // |
| { |
| bool caughtException = false; |
| try |
| { |
| image.geometry(); |
| } |
| catch ( Exception& ) |
| { |
| caughtException = true; |
| } |
| if ( caughtException != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", geometry failed to report missing image geometry"; |
| } |
| } |
| |
| // |
| // gifDisposeMethod |
| // |
| // Test default |
| if ( image.gifDisposeMethod() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", gifDisposeMethod default is not zero as expected" << endl; |
| } |
| |
| // Test set/get |
| image.gifDisposeMethod(BackgroundDispose); |
| if ( image.gifDisposeMethod() != BackgroundDispose ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", gifDisposeMethod set/get failed" << endl; |
| } |
| image.gifDisposeMethod(UndefinedDispose); |
| |
| // |
| // interlaceType |
| // |
| // Test default |
| if ( image.interlaceType() != NoInterlace ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", interlaceType default is not NoInterlace as expected" << endl; |
| } |
| |
| // Test set/get |
| image.interlaceType( PlaneInterlace ); |
| if ( image.interlaceType() != PlaneInterlace ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", interlaceType set/get failed" << endl; |
| } |
| image.interlaceType(NoInterlace); |
| |
| // |
| // label |
| // |
| // Test default |
| if ( image.label().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", label default is not empty string as expected" << endl; |
| } |
| |
| // Test set/get |
| image.label("How now brown cow?"); |
| if ( image.label() != "How now brown cow?" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", label set/get failed" << endl; |
| } |
| // Test set to default |
| image.label( string() ); |
| if ( image.label().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", label failed to unset" << endl; |
| } |
| |
| // |
| // strokeWidth |
| // |
| // Test default |
| if ( image.strokeWidth() != 1 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", strokeWidth default is not 1 as expected" << endl; |
| } |
| |
| // Test set/get |
| image.strokeWidth(2); |
| if ( image.strokeWidth() != 2 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", strokeWidth set/get failed" << endl; |
| } |
| image.strokeWidth(1); |
| |
| // |
| // magick |
| // |
| // Test canvas default |
| if ( image.magick() != "XC" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", magick canvas default is not XC as expected" << endl; |
| } |
| |
| // Test set/get |
| image.magick("GIF"); |
| if ( image.magick() != "GIF" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", magick set/get failed" << endl; |
| } |
| |
| image.magick("XC"); |
| |
| // |
| // alpha |
| // |
| // Test default |
| if ( image.alpha() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", alpha default is not false as expected" << endl; |
| } |
| |
| // Test set/get |
| image.alpha(true); |
| if ( image.alpha() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", alpha set/get failed" << endl; |
| } |
| image.alpha(false); |
| |
| // |
| // matteColor |
| // |
| // Test default |
| if ( image.matteColor() != Color("#BDBDBD") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", matteColor default is not #BDBDBD as expected" << endl; |
| } |
| |
| // Test set/get |
| image.matteColor(ColorRGB(0.5,0.5,1)); |
| if ( image.matteColor() != ColorRGB(0.5,0.5,1) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", matteColor set/get failed" << endl; |
| } |
| |
| // Test unset |
| image.matteColor( Color() ); |
| |
| image.matteColor("#BDBDBD"); |
| |
| // |
| // meanErrorPerPixel |
| // |
| if ( image.meanErrorPerPixel() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", meanErrorPerPixel is not zero as expected" << endl; |
| } |
| |
| // |
| // montageGeometry |
| // |
| { |
| bool caughtException = false; |
| try |
| { |
| image.montageGeometry(); |
| } |
| catch ( Exception& ) |
| { |
| caughtException = true; |
| } |
| if ( caughtException != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", montageGeometry failed to report missing montage geometry"; |
| } |
| } |
| |
| // |
| // monochrome |
| // |
| // Test default |
| if ( image.monochrome() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", monochrome is not false as expected" << endl; |
| } |
| |
| // Test set/get |
| image.monochrome(true); |
| if ( image.monochrome() != true ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", monochrome get/set failed" << endl; |
| } |
| image.monochrome(false); |
| |
| // |
| // normalizedMaxError |
| // |
| if ( image.normalizedMaxError() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ",normalizedMaxError is not zero as expected" << endl; |
| } |
| |
| // |
| // normalizedMeanError |
| // |
| if ( image.normalizedMeanError() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", normalizedMeanError is not zero as expected" << endl; |
| } |
| |
| // |
| // strokeColor |
| // |
| |
| image.strokeColor(ColorRGB(0.5,0.5,1)); |
| if ( image.strokeColor() != ColorRGB(0.5,0.5,1) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", strokeColor (" |
| << string(image.strokeColor()) |
| << ") set/get failed" << endl; |
| } |
| |
| |
| // |
| // fillColor |
| // |
| |
| image.fillColor(ColorRGB(0.5,0.5,1)); |
| if ( image.fillColor() != ColorRGB(0.5,0.5,1) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", fillColor (" |
| << string(image.fillColor()) |
| << ") set/get failed" << endl; |
| } |
| |
| // |
| // pixelColor |
| // |
| // Test default |
| if ( image.pixelColor(40,60) != string(canvasColor) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", pixelColor default (" |
| << string(image.pixelColor(40,60)) |
| << ") is not canvas color (" |
| << string(canvasColor) |
| << ") as expected" << endl; |
| } |
| |
| // Test set/get |
| image.pixelColor(40,60, ColorRGB(0.5,1,1)); |
| if ( image.pixelColor(40,60) != ColorRGB(0.5,1,1) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", pixelColor set/get failed" << endl; |
| } |
| |
| // |
| // page |
| // |
| // Test default |
| if ( image.page() != Geometry(640,480,0,0) ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", page default " |
| << "(" << string(image.page()) << ")" |
| << " is not 640x480 as expected" << endl; |
| } |
| |
| // Test set/get |
| image.page("letter+43+43>"); |
| if ( image.page() != "612x792+43+43" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", page set/get failed (" << string(image.page()) << ")" << endl; |
| } |
| |
| // |
| // quality |
| // |
| // Test default |
| if ( image.quality() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quality default is not 0 as expected" << endl; |
| } |
| |
| // Test set/get |
| image.quality(65); |
| if ( image.quality() != 65 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", quality set/get failed" << endl; |
| } |
| image.quality(0); |
| |
| // |
| // quantizeColors |
| // |
| // Test default |
| if ( image.quantizeColors() != 256 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeColors is not 256 as expected" << endl; |
| } |
| |
| // Test set/get |
| image.quantizeColors(200); |
| if ( image.quantizeColors() != 200 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", quantizeColors set/get failed" << endl; |
| } |
| image.quantizeColors(0); |
| |
| // |
| // quantizeColorSpace |
| // |
| // Test default |
| if ( image.quantizeColorSpace() != UndefinedColorspace ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeColorSpace is not RGBColorspace as expected" << endl; |
| } |
| |
| // Test set/get |
| image.quantizeColorSpace(YIQColorspace); |
| if ( image.quantizeColorSpace() != YIQColorspace ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeColorSpace set/get failed" << endl; |
| } |
| image.quantizeColorSpace(RGBColorspace); |
| |
| // |
| // quantizeDither |
| // |
| // Test default |
| if ( image.quantizeDither() == false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeDither is not false as expected" << endl; |
| } |
| |
| // Test set/get |
| image.quantizeDither(false); |
| if ( image.quantizeDither() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeDither get/set failed" << endl; |
| } |
| image.quantizeDither(true); |
| |
| // |
| // quantizeTreeDepth |
| // |
| if ( image.quantizeTreeDepth() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", quantizeTreeDepth default is " |
| << image.quantizeTreeDepth() |
| << " rather than zero as expected" << endl; |
| } |
| |
| image.quantizeTreeDepth(7); |
| if ( image.quantizeTreeDepth() != 7 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", quantizeTreeDepth set/get failed" << endl; |
| } |
| image.quantizeTreeDepth(8); |
| |
| // |
| // renderingIntent |
| // |
| if ( image.renderingIntent() == UndefinedIntent ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", renderingIntent default is UndefinedIntent as expected" |
| << endl; |
| } |
| |
| image.renderingIntent(PerceptualIntent); |
| if ( image.renderingIntent() != PerceptualIntent ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", renderingIntent set/get failed" << endl; |
| } |
| image.renderingIntent(UndefinedIntent); |
| |
| // |
| // resolutionUnits |
| // |
| if ( image.resolutionUnits() != UndefinedResolution ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", resolutionUnits default is not UndefinedResolution as expected" |
| << endl; |
| } |
| |
| image.resolutionUnits(PixelsPerCentimeterResolution); |
| if ( image.resolutionUnits() != PixelsPerCentimeterResolution ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", resolutionUnits set/get failed" << endl; |
| } |
| image.resolutionUnits(UndefinedResolution); |
| |
| // |
| // rows |
| // |
| if ( image.rows() != rows ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", rows is canvas rows as expected" << endl; |
| } |
| |
| // |
| // scene |
| // |
| if ( image.scene() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", scene default is not zero as expected" << endl; |
| } |
| |
| image.scene(5); |
| if ( image.scene() != 5 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", scene set/get failed" << endl; |
| } |
| image.scene(0); |
| |
| // |
| // signature |
| // |
| |
| if ( |
| ( image.signature() != "6b08f7559b92760e8945b924f514a2e997753eb4408ddf571dd5222a782b8b48") && |
| ( image.signature() != "5e32612a0a3f2f1632d135f8c2df360604b0b84e9f082ddc20efbb0de752a53e") && |
| ( image.signature() != "dba5480face4d9eb973a116fe32ef37a7b47211e563900d21f47d6f0904aba22") && |
| ( image.signature() != "eccb7a8ac230b0deb76c8dd10ddeeb76a0918cbe6e3469d2d9f223d35c66498b") && |
| ( image.signature() != "a0747a8a5a0e6a1ec960ab8994986ba087d518db97db6f17e7bb4da3bbc3c91d") && |
| ( image.signature() != "6857675cd7d967e1e3ff094e1b3e5f4bb3fb9ba2557eb6d083d37881db0a2039") |
| ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", signature (" |
| << image.signature() |
| << ") is incorrect" << endl; |
| image.display(); |
| } |
| |
| // |
| // size |
| // |
| if ( image.size() != geometry ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", size (" |
| << string(image.size()) |
| << ") is not equal to geometry (" |
| << string(geometry) |
| << ")" |
| << endl; |
| } |
| |
| image.size("800x600"); |
| if ( image.size() != Geometry("800x600") ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", size set/get failed" << endl; |
| } |
| image.size( geometry ); |
| |
| // |
| // subImage |
| // |
| if ( image.subImage() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", subImage default is not zero as expected" << endl; |
| } |
| |
| image.subImage(5); |
| if ( image.subImage() != 5 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", subImage set/get failed" << endl; |
| } |
| image.subImage(0); |
| |
| // |
| // subRange |
| // |
| if ( image.subRange() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", subRange default is not zero as expected" << endl; |
| } |
| |
| image.subRange(5); |
| if ( image.subRange() != 5 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", subRange set/get failed" << endl; |
| } |
| image.subRange(0); |
| |
| // |
| // totalColors |
| // |
| if ( image.totalColors() != 2 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ << ", totalColors is " << image.totalColors() |
| << " rather than 2 as expected" << endl; |
| } |
| |
| // |
| // type |
| // |
| image.type(PaletteType); |
| if ( image.type() != PaletteType ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", type is not PaletteType as expected. Reported type " |
| << (int) image.type() << endl; |
| |
| } |
| |
| // |
| // verbose |
| // |
| if ( image.verbose() != false ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", verbose is not false as expected" << endl; |
| } |
| |
| // |
| // x11Display |
| // |
| if ( image.x11Display().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", x11Display default is not empty string as expected" << endl; |
| } |
| |
| image.x11Display(":0.0"); |
| if ( image.x11Display() != ":0.0" ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", x11Display set/get failed" << endl; |
| } |
| |
| image.x11Display( string() ); |
| if ( image.x11Display().length() != 0 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", x11Display failed to unset" << endl; |
| } |
| |
| // |
| // xResolution |
| // |
| if ( image.xResolution() != 72 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", xResolution default (" << image.xResolution() |
| << ") is not zero as expected" << endl; |
| } |
| |
| // |
| // yResolution |
| // |
| if ( image.yResolution() != 72 ) |
| { |
| ++failures; |
| cout << "Line: " << __LINE__ |
| << ", yResolution default (" << image.yResolution() |
| << ") is not zero as expected" << endl; |
| } |
| } |
| catch( Exception &error_ ) |
| { |
| cout << "Caught exception: " << error_.what() << endl; |
| return 1; |
| } |
| catch( exception &error_ ) |
| { |
| cout << "Caught exception: " << error_.what() << endl; |
| return 1; |
| } |
| |
| if ( failures ) |
| { |
| cout << failures << " failures" << endl; |
| return 1; |
| } |
| |
| return 0; |
| } |
