�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2F'>ImageMagick-7.1.2-30</a>/<a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2Ftests%2F'>tests</a>/</p><hr><h3>✏️ Editing: validate.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%                                                                             %
%           V   V   AAA   L      IIIII  DDDD    AAA   TTTTT  EEEEE            %
%           V   V  A   A  L        I    D   D  A   A    T    E                %
%           V   V  AAAAA  L        I    D   D  AAAAA    T    EEE              %
%            V V   A   A  L        I    D   D  A   A    T    E                %
%             V    A   A  LLLLL  IIIII  DDDD   A   A    T    EEEEE            %
%                                                                             %
%                                                                             %
%                        ImageMagick Validation Suite                         %
%                                                                             %
%                             Software Design                                 %
%                                  Cristy                                     %
%                               March 2001                                    %
%                                                                             %
%                                                                             %
%  Copyright 1999 ImageMagick Studio LLC, a non-profit organization           %
%  dedicated to making software imaging solutions freely available.           %
%                                                                             %
%  You may not use this file except in compliance with the License.  You may  %
%  obtain a copy of the License at                                            %
%                                                                             %
%    https://imagemagick.org/license/                                         %
%                                                                             %
%  Unless required by applicable law or agreed to in writing, software        %
%  distributed under the License is distributed on an &quot;AS IS&quot; 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.                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/

/*
  Include declarations.
*/
#include &quot;MagickWand/studio.h&quot;
#include &quot;MagickWand/MagickWand.h&quot;
#include &quot;MagickCore/colorspace-private.h&quot;
#include &quot;MagickCore/gem.h&quot;
#include &quot;MagickCore/resource_.h&quot;
#include &quot;MagickCore/string-private.h&quot;
#include &quot;validate.h&quot;

/*
  Define declarations.
*/
#if defined(__APPLE__)
  #include &quot;TargetConditionals.h&quot;
  #if TARGET_OS_IOS || TARGET_OS_WATCH || TARGET_OS_TV
    #define system(s) ((s)==NULL ? 0 : -1)
  #endif // end iOS
#elif defined(__ANDROID__)
  #define system(s) ((s)==NULL ? 0 : -1)
#endif
#define CIEEpsilon  (216.0/24389.0)
#define CIEK  (24389.0/27.0)
#define D65X  0.95047
#define D65Y  1.0
#define D65Z  1.08883
#define ReferenceEpsilon  ((double) QuantumRange*1.0e-2)

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e C o l o r s p a c e s                                     %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateColorspaces() validates the ImageMagick colorspaces and returns the
%  number of validation tests that passed and failed.
%
%  The format of the ValidateColorspaces method is:
%
%      size_t ValidateColorspaces(size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o fails: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/

static MagickBooleanType ValidateHSIToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  HSIToRGB&quot;);
  ConvertHSIToRGB(111.244375/360.0,0.295985,0.658734,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToHSI()
{
  double
    h,
    i,
    s;

  (void) FormatLocaleFile(stdout,&quot;  RGBToHSI&quot;);
  ConvertRGBToHSI(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;h,&amp;s,&amp;i);
  if ((fabs(h-111.244374/360.0) &gt;= ReferenceEpsilon) ||
      (fabs(s-0.295985) &gt;= ReferenceEpsilon) ||
      (fabs(i-0.658734) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateHSLToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  HSLToRGB&quot;);
  ConvertHSLToRGB(110.200859/360.0,0.882623,0.715163,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToHSL()
{
  double
    h,
    l,
    s;

  (void) FormatLocaleFile(stdout,&quot;  RGBToHSL&quot;);
  ConvertRGBToHSL(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;h,&amp;s,&amp;l);
  if ((fabs(h-110.200859/360.0) &gt;= ReferenceEpsilon) ||
      (fabs(s-0.882623) &gt;= ReferenceEpsilon) ||
      (fabs(l-0.715163) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateHSVToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  HSVToRGB&quot;);
  ConvertHSVToRGB(110.200859/360.0,0.520200,0.966567,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToHSV()
{
  double
    h,
    s,
    v;

  (void) FormatLocaleFile(stdout,&quot;  RGBToHSV&quot;);
  ConvertRGBToHSV(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;h,&amp;s,&amp;v);
  if ((fabs(h-110.200859/360.0) &gt;= ReferenceEpsilon) ||
      (fabs(s-0.520200) &gt;= ReferenceEpsilon) ||
      (fabs(v-0.966567) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToJPEGYCbCr()
{
  double
    Cb,
    Cr,
    Y;

  (void) FormatLocaleFile(stdout,&quot;  RGBToJPEGYCbCr&quot;);
  ConvertRGBToYCbCr(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;Y,&amp;Cb,&amp;Cr);
  if ((fabs(Y-0.783460) &gt;= ReferenceEpsilon) ||
      (fabs(Cb-0.319581) &gt;= ReferenceEpsilon) ||
      (fabs(Cr-0.330539) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateJPEGYCbCrToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  JPEGYCbCrToRGB&quot;);
  ConvertYCbCrToRGB(0.783460,0.319581,0.330539,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateLabToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  LabToRGB&quot;);
  ConvertLabToRGB(88.456154/100.0,-54.671483/255+0.5,51.662818/255.0+0.5,
    D65Illuminant,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToLab()
{
  double
    a,
    b,
    L;

  (void) FormatLocaleFile(stdout,&quot;  RGBToLab&quot;);
  ConvertRGBToLab(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,D65Illuminant,&amp;L,&amp;a,&amp;b);
  if ((fabs(L-(88.456154/100.0)) &gt;= ReferenceEpsilon) ||
      (fabs(a-(-54.671483/255.0+0.5)) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-(51.662818/255.0+0.5)) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateLchToRGB()
{
  double
    b,
    g,
    r;

  (void) FormatLocaleFile(stdout,&quot;  LchToRGB&quot;);
  ConvertLCHabToRGB(88.456154/100.0,75.219797/255.0+0.5,136.620717/360.0,
    D65Illuminant,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToLch()
{
  double
    c,
    h,
    L;

  (void) FormatLocaleFile(stdout,&quot;  RGBToLch&quot;);
  ConvertRGBToLCHab(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,D65Illuminant,&amp;L,&amp;c,&amp;h);
  if ((fabs(L-88.456154/100.0) &gt;= ReferenceEpsilon) ||
      (fabs(c-(75.219797/255.0+0.5)) &gt;= ReferenceEpsilon) ||
      (fabs(h-(136.620717/255.0+0.5)) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToLMS()
{
  double
    L,
    M,
    S;

  (void) FormatLocaleFile(stdout,&quot;  RGBToLMS&quot;);
  ConvertRGBToLMS(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;L,&amp;M,&amp;S);
  if ((fabs(L-0.611749) &gt;= ReferenceEpsilon) ||
      (fabs(M-0.910088) &gt;= ReferenceEpsilon) ||
      (fabs(S-0.294880) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateLMSToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  LMSToRGB&quot;);
  ConvertLMSToRGB(0.611749,0.910088,0.294880,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToLuv()
{
  double
    l,
    u,
    v;

  (void) FormatLocaleFile(stdout,&quot;  RGBToLuv&quot;);
  ConvertRGBToLuv(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,D65Illuminant,&amp;l,&amp;u,&amp;v);
  if ((fabs(l-88.456154/262.0) &gt;= ReferenceEpsilon) ||
      (fabs(u-(-51.330414+134.0)/354.0) &gt;= ReferenceEpsilon) ||
      (fabs(v-(76.405526+140.0)/262.0) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateLuvToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  LuvToRGB&quot;);
  ConvertLuvToRGB(88.456154/100.0,(-51.330414+134.0)/354.0,
    (76.405526+140.0)/262.0,D65Illuminant,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToXYZ()
{
  double
    x,
    y,
    z;

  (void) FormatLocaleFile(stdout,&quot;  RGBToXYZ&quot;);
  ConvertRGBToXYZ(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;x,&amp;y,&amp;z);
  if ((fabs(x-0.470646) &gt;= ReferenceEpsilon) ||
      (fabs(y-0.730178) &gt;= ReferenceEpsilon) ||
      (fabs(z-0.288324) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateXYZToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  XYZToRGB&quot;);
  ConvertXYZToRGB(0.470646,0.730178,0.288324,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateYDbDrToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  YDbDrToRGB&quot;);
  ConvertYDbDrToRGB(0.783460,-0.480932+0.5,0.451670+0.5,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToYDbDr()
{
  double
    Db,
    Dr,
    Y;

  (void) FormatLocaleFile(stdout,&quot;  RGBToYDbDr&quot;);
  ConvertRGBToYDbDr(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;Y,&amp;Db,&amp;Dr);
  if ((fabs(Y-0.783460) &gt;= ReferenceEpsilon) ||
      (fabs(Db-(-0.480932)) &gt;= ReferenceEpsilon) ||
      (fabs(Dr-0.451670) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToYIQ()
{
  double
    i,
    q,
    y;

  (void) FormatLocaleFile(stdout,&quot;  RGBToYIQ&quot;);
  ConvertRGBToYIQ(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;y,&amp;i,&amp;q);
  if ((fabs(y-0.783460) &gt;= ReferenceEpsilon) ||
      (fabs(i-(-0.089078)) &gt;= ReferenceEpsilon) ||
      (fabs(q-(-0.245399)) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateYIQToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  YIQToRGB&quot;);
  ConvertYIQToRGB(0.783460,-0.089078+0.5,-0.245399+0.5,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToYPbPr()
{
  double
    Pb,
    Pr,
    y;

  (void) FormatLocaleFile(stdout,&quot;  RGBToYPbPr&quot;);
  ConvertRGBToYPbPr(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;y,&amp;Pb,&amp;Pr);
  if ((fabs(y-0.783460) &gt;= ReferenceEpsilon) ||
      (fabs(Pb-(-0.180419)) &gt;= ReferenceEpsilon) ||
      (fabs(Pr-(-0.169461)) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateYPbPrToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  YPbPrToRGB&quot;);
  ConvertYPbPrToRGB(0.783460,-0.180419+0.5,-0.169461+0.5,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateRGBToYUV()
{
  double
    U,
    V,
    Y;

  (void) FormatLocaleFile(stdout,&quot;  RGBToYUV&quot;);
  ConvertRGBToYUV(0.545877*(double) QuantumRange,0.966567*(double)
    QuantumRange,0.463759*(double) QuantumRange,&amp;Y,&amp;U,&amp;V);
  if ((fabs(Y-0.783460) &gt;= ReferenceEpsilon) ||
      (fabs(U-(-0.157383)) &gt;= ReferenceEpsilon) ||
      (fabs(V-(-0.208443)) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static MagickBooleanType ValidateYUVToRGB()
{
  double
    r,
    g,
    b;

  (void) FormatLocaleFile(stdout,&quot;  YUVToRGB&quot;);
  ConvertYUVToRGB(0.783460,-0.157383+0.5,-0.208443+0.5,&amp;r,&amp;g,&amp;b);
  if ((fabs((double) r-0.545877*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) g-0.966567*(double) QuantumRange) &gt;= ReferenceEpsilon) ||
      (fabs((double) b-0.463759*(double) QuantumRange) &gt;= ReferenceEpsilon))
    return(MagickFalse);
  return(MagickTrue);
}

static size_t ValidateColorspaces(size_t *fails,ExceptionInfo *exception)
{
  MagickBooleanType
    status;

  size_t
    fail,
    test;

  /*
     Reference: https://code.google.com/p/chroma.

     Illuminant =  D65
     Observer   =  2° (1931)

     XYZ            0.470645,   0.730177,   0.288323
     sRGB           0.545877,   0.966567,   0.463759
     CAT02 LMS      0.611749,   0.910088,   0.294880
     Y&#039;DbDr         0.783460,  -0.480932,   0.451670
     Y&#039;IQ           0.783460,  -0.089078,  -0.245399
     Y&#039;PbPr         0.783460,  -0.180419,  -0.169461
     Y&#039;UV           0.783460,  -0.157383,  -0.208443
     JPEG-Y&#039;CbCr    0.783460,   0.319581,   0.330539
     L*u*v*        88.456154, -51.330414,  76.405526
     L*a*b*        88.456154, -54.671483,  51.662818
     L*C*H*        88.456154,  75.219797, 136.620717
     HSV          110.200859,   0.520200,   0.966567
     HSL          110.200859,   0.882623,   0.715163
     HSI          111.244375,   0.295985,   0.658734
     Y&#039;CbCr       187.577791,  87.586330,  90.040886
  */
  (void) FormatLocaleFile(stdout,&quot;validate colorspaces:\n&quot;);
  fail=0;
  for (test=0; test &lt; 26; test++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: &quot;,(double) test);
    switch (test)
    {
      case  0: status=ValidateHSIToRGB(); break;
      case  1: status=ValidateRGBToHSI(); break;
      case  2: status=ValidateHSLToRGB(); break;
      case  3: status=ValidateRGBToHSL(); break;
      case  4: status=ValidateHSVToRGB(); break;
      case  5: status=ValidateRGBToHSV(); break;
      case  6: status=ValidateJPEGYCbCrToRGB(); break;
      case  7: status=ValidateRGBToJPEGYCbCr(); break;
      case  8: status=ValidateLabToRGB(); break;
      case  9: status=ValidateRGBToLab(); break;
      case 10: status=ValidateLchToRGB(); break;
      case 11: status=ValidateRGBToLch(); break;
      case 12: status=ValidateLMSToRGB(); break;
      case 13: status=ValidateRGBToLMS(); break;
      case 14: status=ValidateLuvToRGB(); break;
      case 15: status=ValidateRGBToLuv(); break;
      case 16: status=ValidateXYZToRGB(); break;
      case 17: status=ValidateRGBToXYZ(); break;
      case 18: status=ValidateYDbDrToRGB(); break;
      case 19: status=ValidateRGBToYDbDr(); break;
      case 20: status=ValidateYIQToRGB(); break;
      case 21: status=ValidateRGBToYIQ(); break;
      case 22: status=ValidateYPbPrToRGB(); break;
      case 23: status=ValidateRGBToYPbPr(); break;
      case 24: status=ValidateYUVToRGB(); break;
      case 25: status=ValidateRGBToYUV(); break;
      default: status=MagickFalse;
    }
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e C o m p a r e C o m m a n d                               %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateCompareCommand() validates the ImageMagick compare command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateCompareCommand method is:
%
%      size_t ValidateCompareCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateCompareCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate compare command line program:\n&quot;);
  for (i=0; compare_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) (test++),
      compare_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s %s&quot;,
      compare_options[i],reference_filename,reference_filename,output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        (void) LogMagickEvent(ExceptionEvent,GetMagickModule(),&quot;%s&quot;,
          exception-&gt;reason);
        fail++;
        continue;
      }
    status=CompareImagesCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        (void) LogMagickEvent(ExceptionEvent,GetMagickModule(),&quot;%s&quot;,
          exception-&gt;reason);
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e C o m p o s i t e C o m m a n d                           %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateCompositeCommand() validates the ImageMagick composite command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateCompositeCommand method is:
%
%      size_t ValidateCompositeCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateCompositeCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate composite command line program:\n&quot;);
  for (i=0; composite_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) (test++),
      composite_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s %s&quot;,
      reference_filename,composite_options[i],reference_filename,
      output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    status=CompositeImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e C o n v e r t C o m m a n d                               %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateConvertCommand() validates the ImageMagick convert command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateConvertCommand method is:
%
%      size_t ValidateConvertCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateConvertCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate convert command line program:\n&quot;);
  for (i=0; convert_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) test++,
      convert_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s %s&quot;,
      reference_filename,convert_options[i],reference_filename,output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    status=ConvertImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e I d e n t i f y C o m m a n d                             %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateIdentifyCommand() validates the ImageMagick identify command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateIdentifyCommand method is:
%
%      size_t ValidateIdentifyCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateIdentifyCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  (void) output_filename;
  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate identify command line program:\n&quot;);
  for (i=0; identify_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) test++,
      identify_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s&quot;,
      identify_options[i],reference_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    status=IdentifyImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e I m a g e F o r m a t s I n M e m o r y                   %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateImageFormatsInMemory() validates the ImageMagick image formats in
%  memory and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateImageFormatsInMemory method is:
%
%      size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/

/*
  Enable this to count remaining $TMPDIR/magick-* files.  Note that the count
  includes any files left over from other runs.
*/
#undef MagickCountTempFiles

static size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
#ifdef MagickCountTempFiles
    path[MagickPathExtent],
    SystemCommand[MagickPathExtent],
#endif
    size[MagickPathExtent];

  const MagickInfo
    *magick_info;

  double
    distortion,
    fuzz;

  Image
    *difference_image,
    *ping_image,
    *reconstruct_image,
    *reference_image;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    length,
    test;

  unsigned char
    *blob;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate image formats in memory:\n&quot;);

#ifdef MagickCountTempFiles
  (void)GetPathTemplate(path);
  /* Remove file template except for the leading &quot;/path/to/magick-&quot; */
  path[strlen(path)-17]=&#039;\0&#039;;
  (void) FormatLocaleFile(stdout,&quot; tmp path is &#039;%s*&#039;\n&quot;,path);
#endif

  for (i=0; reference_formats[i].magick != (char *) NULL; i++)
  {
    magick_info=GetMagickInfo(reference_formats[i].magick,exception);
    if ((magick_info == (const MagickInfo *) NULL) ||
        (magick_info-&gt;decoder == (DecodeImageHandler *) NULL) ||
        (magick_info-&gt;encoder == (EncodeImageHandler *) NULL))
      continue;
    for (j=0; reference_types[j].type != UndefinedType; j++)
    {
      /*
        Generate reference image.
      */
      CatchException(exception);
      (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s/%s/%s/%.17g-bits&quot;,
        (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
        MagickCompressOptions,reference_formats[i].compression),
        CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
        (double) reference_types[j].depth);
      (void) CopyMagickString(image_info-&gt;filename,reference_filename,
        MagickPathExtent);
      reference_image=ReadImage(image_info,exception);
      if ((reference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Write reference image.
      */
      (void) FormatLocaleString(size,MagickPathExtent,&quot;%.17gx%.17g&quot;,
        (double) reference_image-&gt;columns,(double) reference_image-&gt;rows);
      (void) CloneString(&amp;image_info-&gt;size,size);
      image_info-&gt;depth=reference_types[j].depth;
      (void) FormatLocaleString(reference_image-&gt;filename,MagickPathExtent,
        &quot;%s:%s&quot;,reference_formats[i].magick,output_filename);
      status=SetImageType(reference_image,reference_types[j].type,exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      status=SetImageDepth(reference_image,reference_types[j].depth,exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      reference_image-&gt;compression=reference_formats[i].compression;
      status=WriteImage(image_info,reference_image,exception);
      reference_image=DestroyImage(reference_image);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Ping reference image.
      */
      (void) FormatLocaleString(image_info-&gt;filename,MagickPathExtent,&quot;%s:%s&quot;,
        reference_formats[i].magick,output_filename);
      ping_image=PingImage(image_info,exception);
      if (ping_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      ping_image=DestroyImage(ping_image);
      /*
        Read reference image.
      */
      reference_image=ReadImage(image_info,exception);
      if ((reference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Write reference image.
      */
      (void) FormatLocaleString(reference_image-&gt;filename,MagickPathExtent,
        &quot;%s:%s&quot;,reference_formats[i].magick,output_filename);
      (void) CopyMagickString(image_info-&gt;magick,reference_formats[i].magick,
        MagickPathExtent);
      reference_image-&gt;depth=reference_types[j].depth;
      reference_image-&gt;compression=reference_formats[i].compression;
      length=8192;
      blob=(unsigned char *) ImageToBlob(image_info,reference_image,&amp;length,
        exception);
      if ((blob == (unsigned char *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Ping reference blob.
      */
      ping_image=PingBlob(image_info,blob,length,exception);
      if (ping_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          blob=(unsigned char *) RelinquishMagickMemory(blob);
          continue;
        }
      ping_image=DestroyImage(ping_image);
      /*
        Read reconstruct image.
      */
      (void) FormatLocaleString(image_info-&gt;filename,MagickPathExtent,&quot;%s:%s&quot;,
        reference_formats[i].magick,output_filename);
      reconstruct_image=BlobToImage(image_info,blob,length,exception);
      blob=(unsigned char *) RelinquishMagickMemory(blob);
      if (reconstruct_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Compare reference to reconstruct image.
      */
      fuzz=0.003;  /* grayscale */
      if (reference_formats[i].fuzz != 0.0)
        fuzz=reference_formats[i].fuzz;
      difference_image=CompareImages(reference_image,reconstruct_image,
        RootMeanSquaredErrorMetric,&amp;distortion,exception);
      reconstruct_image=DestroyImage(reconstruct_image);
      reference_image=DestroyImage(reference_image);
      if ((difference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      difference_image=DestroyImage(difference_image);
      if (MagickSafeSignificantError(QuantumScale*distortion,fuzz) != MagickFalse)
        {
          (void) FormatLocaleFile(stdout,&quot;... fail (with distortion %g).\n&quot;,
            QuantumScale*distortion);
          fail++;
          continue;
        }
#ifdef MagickCountTempFiles
      (void) FormatLocaleFile(stdout,&quot;... pass, &quot;);
      (void) fflush(stdout);
      SystemCommand[0]=&#039;\0&#039;;
      (void) strncat(SystemCommand,&quot;echo `ls &quot;,9);
      (void) strncat(SystemCommand,path,MagickPathExtent-31);
      (void) strncat(SystemCommand,&quot;* | wc -w` tmp files.&quot;,20);
      (void) system(SystemCommand);
      (void) fflush(stdout);
#else
      (void) FormatLocaleFile(stdout,&quot;... pass\n&quot;);
#endif
    }
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e I m a g e F o r m a t s O n D i s k                       %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateImageFormatsOnDisk() validates the ImageMagick image formats on disk
%  and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateImageFormatsOnDisk method is:
%
%      size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    size[MagickPathExtent];

  const MagickInfo
    *magick_info;

  double
    distortion,
    fuzz;

  Image
    *difference_image,
    *reference_image,
    *reconstruct_image;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate image formats on disk:\n&quot;);
  for (i=0; reference_formats[i].magick != (char *) NULL; i++)
  {
    magick_info=GetMagickInfo(reference_formats[i].magick,exception);
    if ((magick_info == (const MagickInfo *) NULL) ||
        (magick_info-&gt;decoder == (DecodeImageHandler *) NULL) ||
        (magick_info-&gt;encoder == (EncodeImageHandler *) NULL))
      continue;
    for (j=0; reference_types[j].type != UndefinedType; j++)
    {
      /*
        Generate reference image.
      */
      CatchException(exception);
      (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s/%s/%s/%.17g-bits&quot;,
        (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
        MagickCompressOptions,reference_formats[i].compression),
        CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
        (double) reference_types[j].depth);
      (void) CopyMagickString(image_info-&gt;filename,reference_filename,
        MagickPathExtent);
      reference_image=ReadImage(image_info,exception);
      if ((reference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Write reference image.
      */
      (void) FormatLocaleString(size,MagickPathExtent,&quot;%.17gx%.17g&quot;,
        (double) reference_image-&gt;columns,(double) reference_image-&gt;rows);
      (void) CloneString(&amp;image_info-&gt;size,size);
      image_info-&gt;depth=reference_types[j].depth;
      (void) FormatLocaleString(reference_image-&gt;filename,MagickPathExtent,
        &quot;%s:%s&quot;,reference_formats[i].magick,output_filename);
      status=SetImageType(reference_image,reference_types[j].type,exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      status=SetImageDepth(reference_image,reference_types[j].depth,exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      reference_image-&gt;compression=reference_formats[i].compression;
      status=WriteImage(image_info,reference_image,exception);
      reference_image=DestroyImage(reference_image);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          if (exception-&gt;reason != (char *) NULL)
            (void) FormatLocaleFile(stdout,&quot;    reason:%s\n&quot;,exception-&gt;reason);
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Read reference image.
      */
      (void) FormatLocaleString(image_info-&gt;filename,MagickPathExtent,&quot;%s:%s&quot;,
        reference_formats[i].magick,output_filename);
      reference_image=ReadImage(image_info,exception);
      if ((reference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          continue;
        }
      /*
        Write reference image.
      */
      (void) FormatLocaleString(reference_image-&gt;filename,MagickPathExtent,
        &quot;%s:%s&quot;,reference_formats[i].magick,output_filename);
      reference_image-&gt;depth=reference_types[j].depth;
      reference_image-&gt;compression=reference_formats[i].compression;
      status=WriteImage(image_info,reference_image,exception);
      if (status == MagickFalse ||exception-&gt;severity &gt;= ErrorException)
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Read reconstruct image.
      */
      (void) FormatLocaleString(image_info-&gt;filename,MagickPathExtent,&quot;%s:%s&quot;,
        reference_formats[i].magick,output_filename);
      reconstruct_image=ReadImage(image_info,exception);
      if (reconstruct_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Compare reference to reconstruct image.
      */
      fuzz=0.003;  /* grayscale */
      if (reference_formats[i].fuzz != 0.0)
        fuzz=reference_formats[i].fuzz;
      difference_image=CompareImages(reference_image,reconstruct_image,
        RootMeanSquaredErrorMetric,&amp;distortion,exception);
      reconstruct_image=DestroyImage(reconstruct_image);
      reference_image=DestroyImage(reference_image);
      if (difference_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          continue;
        }
      difference_image=DestroyImage(difference_image);
      if (MagickSafeSignificantError(QuantumScale*distortion,fuzz) != MagickFalse)
        {
          (void) FormatLocaleFile(stdout,&quot;... fail (with distortion %g).\n&quot;,
            QuantumScale*distortion);
          fail++;
          continue;
        }
      (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
    }
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e I m p o r t E x p o r t P i x e l s                       %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateImportExportPixels() validates the pixel import and export methods.
%  It returns the number of validation tests that passed and failed.
%
%  The format of the ValidateImportExportPixels method is:
%
%      size_t ValidateImportExportPixels(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateImportExportPixels(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  double
    distortion;

  Image
    *difference_image,
    *reference_image,
    *reconstruct_image;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    length;

  unsigned char
    *pixels;

  size_t
    fail,
    test;

  (void) output_filename;
  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,
    &quot;validate the import and export of image pixels:\n&quot;);
  for (i=0; reference_map[i] != (char *) NULL; i++)
  {
    for (j=0; reference_storage[j].type != UndefinedPixel; j++)
    {
      /*
        Generate reference image.
      */
      CatchException(exception);
      (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s/%s&quot;,(double) (test++),
        reference_map[i],CommandOptionToMnemonic(MagickStorageOptions,
        reference_storage[j].type));
      (void) CopyMagickString(image_info-&gt;filename,reference_filename,
        MagickPathExtent);
      reference_image=ReadImage(image_info,exception);
      if ((reference_image == (Image *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          continue;
        }
      if (LocaleNCompare(reference_map[i],&quot;cmy&quot;,3) == 0)
        (void) SetImageColorspace(reference_image,CMYKColorspace,exception);
      length=strlen(reference_map[i])*reference_image-&gt;columns*
        reference_image-&gt;rows*reference_storage[j].quantum;
      pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
      if ((pixels == (unsigned char *) NULL) ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      (void) memset(pixels,0,length*sizeof(*pixels));
      status=ExportImagePixels(reference_image,0,0,reference_image-&gt;columns,
        reference_image-&gt;rows,reference_map[i],reference_storage[j].type,pixels,
        exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          pixels=(unsigned char *) RelinquishMagickMemory(pixels);
          reference_image=DestroyImage(reference_image);
          continue;
        }
      (void) SetImageBackgroundColor(reference_image,exception);
      status=ImportImagePixels(reference_image,0,0,reference_image-&gt;columns,
        reference_image-&gt;rows,reference_map[i],reference_storage[j].type,
        pixels,exception);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
           pixels=(unsigned char *) RelinquishMagickMemory(pixels);
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Read reconstruct image.
      */
      reconstruct_image=AcquireImage(image_info,exception);
      (void) SetImageExtent(reconstruct_image,reference_image-&gt;columns,
        reference_image-&gt;rows,exception);
      (void) SetImageColorspace(reconstruct_image,reference_image-&gt;colorspace,
        exception);
      (void) SetImageBackgroundColor(reconstruct_image,exception);
      status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image-&gt;columns,
        reconstruct_image-&gt;rows,reference_map[i],reference_storage[j].type,
        pixels,exception);
      pixels=(unsigned char *) RelinquishMagickMemory(pixels);
      if (status == MagickFalse || (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          reference_image=DestroyImage(reference_image);
          continue;
        }
      /*
        Compare reference to reconstruct image.
      */
      difference_image=CompareImages(reference_image,reconstruct_image,
        RootMeanSquaredErrorMetric,&amp;distortion,exception);
      reconstruct_image=DestroyImage(reconstruct_image);
      reference_image=DestroyImage(reference_image);
      if (difference_image == (Image *) NULL ||
          (exception-&gt;severity &gt;= ErrorException))
        {
          (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
          CatchException(exception);
          fail++;
          continue;
        }
      difference_image=DestroyImage(difference_image);
      if ((QuantumScale*distortion) &gt; 0.0)
        {
          (void) FormatLocaleFile(stdout,&quot;... fail (with distortion %g).\n&quot;,
            QuantumScale*distortion);
          fail++;
          continue;
        }
      (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
    }
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e M a g i c k C o m m a n d                                 %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateMagickCommand() validates the ImageMagick magick command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateMagickCommand method is:
%
%      size_t ValidateMagickCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateMagickCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate magick command line program:\n&quot;);
  for (i=0; convert_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) test++,
      convert_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s %s&quot;,
      reference_filename,convert_options[i],reference_filename,output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    status=MagickImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e M o n t a g e C o m m a n d                               %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateMontageCommand() validates the ImageMagick montage command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateMontageCommand method is:
%
%      size_t ValidateMontageCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateMontageCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate montage command line program:\n&quot;);
  for (i=0; montage_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) (test++),
      montage_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s %s&quot;,
      reference_filename,montage_options[i],reference_filename,
      output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
        fail++;
        continue;
      }
    status=MontageImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
            GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   V a l i d a t e S t r e a m C o m m a n d                                 %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  ValidateStreamCommand() validates the ImageMagick stream command line
%  program and returns the number of validation tests that passed and failed.
%
%  The format of the ValidateStreamCommand method is:
%
%      size_t ValidateStreamCommand(ImageInfo *image_info,
%        const char *reference_filename,const char *output_filename,
%        size_t *fails,ExceptionInfo *exception)
%
%  A description of each parameter follows:
%
%    o image_info: the image info.
%
%    o reference_filename: the reference image filename.
%
%    o output_filename: the output image filename.
%
%    o fail: return the number of validation tests that pass.
%
%    o exception: return any errors or warnings in this structure.
%
*/
static size_t ValidateStreamCommand(ImageInfo *image_info,
  const char *reference_filename,const char *output_filename,size_t *fails,
  ExceptionInfo *exception)
{
  char
    **arguments,
    command[MagickPathExtent];

  int
    number_arguments;

  MagickBooleanType
    status;

  ssize_t
    i,
    j;

  size_t
    fail,
    test;

  fail=0;
  test=0;
  (void) FormatLocaleFile(stdout,&quot;validate stream command line program:\n&quot;);
  for (i=0; stream_options[i] != (char *) NULL; i++)
  {
    CatchException(exception);
    (void) FormatLocaleFile(stdout,&quot;  test %.17g: %s&quot;,(double) (test++),
      stream_options[i]);
    (void) FormatLocaleString(command,MagickPathExtent,&quot;%s %s %s&quot;,
      stream_options[i],reference_filename,output_filename);
    arguments=StringToArgv(command,&amp;number_arguments);
    if (arguments == (char **) NULL)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    status=StreamImageCommand(image_info,number_arguments,arguments,
      (char **) NULL,exception);
    for (j=0; j &lt; (ssize_t) number_arguments; j++)
      arguments[j]=DestroyString(arguments[j]);
    arguments=(char **) RelinquishMagickMemory(arguments);
    if (status == MagickFalse)
      {
        (void) FormatLocaleFile(stdout,&quot;... fail @ %s/%s/%lu.\n&quot;,
          GetMagickModule());
        fail++;
        continue;
      }
    (void) FormatLocaleFile(stdout,&quot;... pass.\n&quot;);
  }
  (void) FormatLocaleFile(stdout,
    &quot;  summary: %.17g subtests; %.17g passed; %.17g failed.\n&quot;,(double) test,
    (double) (test-fail),(double) fail);
  *fails+=fail;
  return(test);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%  M a i n                                                                    %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/

static MagickBooleanType ValidateUsage(void)
{
  const char
    **p;

  static const char
    *miscellaneous[]=
    {
      &quot;-debug events        display copious debugging information&quot;,
      &quot;-help                print program options&quot;,
      &quot;-log format          format of debugging information&quot;,
      &quot;-validate type       validation type&quot;,
      &quot;-version             print version information&quot;,
      (char *) NULL
    },
    *settings[]=
    {
      &quot;-regard-warnings     pay attention to warning messages&quot;,
      &quot;-verbose             print detailed information about the image&quot;,
      (char *) NULL
    };

  (void) printf(&quot;Version: %s\n&quot;,GetMagickVersion((size_t *) NULL));
  (void) printf(&quot;Copyright: %s\n\n&quot;,GetMagickCopyright());
  (void) printf(&quot;Features: %s\n&quot;,GetMagickFeatures());
  (void) printf(&quot;Usage: %s [options ...] reference-file\n&quot;,GetClientName());
  (void) printf(&quot;\nValidate Settings:\n&quot;);
  for (p=settings; *p != (char *) NULL; p++)
    (void) printf(&quot;  %s\n&quot;,*p);
  (void) printf(&quot;\nMiscellaneous Options:\n&quot;);
  for (p=miscellaneous; *p != (char *) NULL; p++)
    (void) printf(&quot;  %s\n&quot;,*p);
  return(MagickTrue);
}

int main(int argc,char **argv)
{
#define DestroyValidate() \
{ \
  image_info=DestroyImageInfo(image_info); \
  exception=DestroyExceptionInfo(exception); \
}
#define ThrowValidateException(asperity,tag,option) \
{ \
  (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,&quot;`%s&#039;&quot;, \
    option); \
  CatchException(exception); \
  DestroyValidate(); \
  return(MagickFalse); \
}

  char
    output_filename[MagickPathExtent],
    reference_filename[MagickPathExtent],
    *option;

  double
    elapsed_time,
    user_time;

  ExceptionInfo
    *exception;

  Image
    *reference_image;

  ImageInfo
    *image_info;

  MagickBooleanType
    regard_warnings,
    status;

  MagickSizeType
    memory_resource,
    map_resource;

  ssize_t
    i;

  TimerInfo
    *timer;

  size_t
    fail,
    iterations,
    tests;

  ValidateType
    type;

  /*
    Validate the ImageMagick image processing suite.
  */
  MagickCoreGenesis(*argv,MagickTrue);
  (void) setlocale(LC_ALL,&quot;&quot;);
  (void) setlocale(LC_NUMERIC,&quot;C&quot;);
  iterations=1;
  status=MagickFalse;
  type=AllValidate;
  regard_warnings=MagickFalse;
  (void) regard_warnings;
  exception=AcquireExceptionInfo();
  image_info=AcquireImageInfo();
  (void) CopyMagickString(image_info-&gt;filename,ReferenceFilename,
    MagickPathExtent);
  for (i=1; i &lt; (ssize_t) argc; i++)
  {
    option=argv[i];
    if (IsCommandOption(option) == MagickFalse)
      {
        (void) CopyMagickString(image_info-&gt;filename,option,MagickPathExtent);
        continue;
      }
    switch (*(option+1))
    {
      case &#039;b&#039;:
      {
        if (LocaleCompare(&quot;bench&quot;,option+1) == 0)
          {
            iterations=StringToUnsignedLong(argv[++i]);
            break;
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;d&#039;:
      {
        if (LocaleCompare(&quot;debug&quot;,option+1) == 0)
          {
            (void) SetLogEventMask(argv[++i]);
            break;
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;h&#039;:
      {
        if (LocaleCompare(&quot;help&quot;,option+1) == 0)
          {
            (void) ValidateUsage();
            return(0);
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;l&#039;:
      {
        if (LocaleCompare(&quot;log&quot;,option+1) == 0)
          {
            if (*option != &#039;+&#039;)
              (void) SetLogFormat(argv[i+1]);
            break;
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;r&#039;:
      {
        if (LocaleCompare(&quot;regard-warnings&quot;,option+1) == 0)
          {
            regard_warnings=MagickTrue;
            break;
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      case &#039;v&#039;:
      {
        if (LocaleCompare(&quot;validate&quot;,option+1) == 0)
          {
            ssize_t
              validate;

            if (*option == &#039;+&#039;)
              break;
            i++;
            if (i &gt;= (ssize_t) argc)
              ThrowValidateException(OptionError,&quot;MissingArgument&quot;,option);
            validate=ParseCommandOption(MagickValidateOptions,MagickFalse,
              argv[i]);
            if (validate &lt; 0)
              ThrowValidateException(OptionError,&quot;UnrecognizedValidateType&quot;,
                argv[i]);
            type=(ValidateType) validate;
            break;
          }
        if ((LocaleCompare(&quot;version&quot;,option+1) == 0) ||
            (LocaleCompare(&quot;-version&quot;,option+1) == 0))
          {
            (void) FormatLocaleFile(stdout,&quot;Version: %s\n&quot;,
              GetMagickVersion((size_t *) NULL));
            (void) FormatLocaleFile(stdout,&quot;Copyright: %s\n\n&quot;,
              GetMagickCopyright());
            (void) FormatLocaleFile(stdout,&quot;Features: %s\n\n&quot;,
              GetMagickFeatures());
            return(0);
          }
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
      }
      default:
        ThrowValidateException(OptionError,&quot;UnrecognizedOption&quot;,option)
    }
  }
  timer=(TimerInfo *) NULL;
  if (iterations &gt; 1)
    timer=AcquireTimerInfo();
  reference_image=ReadImage(image_info,exception);
  tests=0;
  fail=0;
  if (reference_image == (Image *) NULL)
    fail++;
  else
    {
      if (LocaleCompare(image_info-&gt;filename,ReferenceFilename) == 0)
        (void) CopyMagickString(reference_image-&gt;magick,ReferenceImageFormat,
          MagickPathExtent);
      (void) AcquireUniqueFilename(reference_filename);
      (void) AcquireUniqueFilename(output_filename);
      (void) CopyMagickString(reference_image-&gt;filename,reference_filename,
        MagickPathExtent);
      status=WriteImage(image_info,reference_image,exception);
      reference_image=DestroyImage(reference_image);
      if (status == MagickFalse)
        fail++;
      else
        {
          (void) FormatLocaleFile(stdout,&quot;Version: %s\n&quot;,
            GetMagickVersion((size_t *) NULL));
          (void) FormatLocaleFile(stdout,&quot;Copyright: %s\n\n&quot;,
            GetMagickCopyright());
          (void) FormatLocaleFile(stdout,
            &quot;ImageMagick Validation Suite (%s)\n\n&quot;,CommandOptionToMnemonic(
            MagickValidateOptions,(ssize_t) type));
          if ((type &amp; ColorspaceValidate) != 0)
            tests+=ValidateColorspaces(&amp;fail,exception);
          if ((type &amp; CompareValidate) != 0)
            tests+=ValidateCompareCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; CompositeValidate) != 0)
            tests+=ValidateCompositeCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; ConvertValidate) != 0)
            tests+=ValidateConvertCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; FormatsDiskValidate) != 0)
            {
              memory_resource=SetMagickResourceLimit(MemoryResource,0);
              map_resource=SetMagickResourceLimit(MapResource,0);
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: disk] &quot;);
              tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
                output_filename,&amp;fail,exception);
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: disk] &quot;);
              tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
                output_filename,&amp;fail,exception);
              (void) SetMagickResourceLimit(MemoryResource,memory_resource);
              (void) SetMagickResourceLimit(MapResource,map_resource);
            }
          if ((type &amp; FormatsMapValidate) != 0)
            {
              memory_resource=SetMagickResourceLimit(MemoryResource,0);
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: memory-mapped] &quot;);
              tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
                output_filename,&amp;fail,exception);
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: memory-mapped] &quot;);
              tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
                output_filename,&amp;fail,exception);
              (void) SetMagickResourceLimit(MemoryResource,memory_resource);
            }
          if ((type &amp; FormatsMemoryValidate) != 0)
            {
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: memory] &quot;);
              tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
                output_filename,&amp;fail,exception);
              (void) FormatLocaleFile(stdout,&quot;[pixel-cache: memory] &quot;);
              tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
                output_filename,&amp;fail,exception);
            }
          if ((type &amp; IdentifyValidate) != 0)
            tests+=ValidateIdentifyCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; ImportExportValidate) != 0)
            tests+=ValidateImportExportPixels(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; MagickValidate) != 0)
            tests+=ValidateMagickCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; MontageValidate) != 0)
            tests+=ValidateMontageCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          if ((type &amp; StreamValidate) != 0)
            tests+=ValidateStreamCommand(image_info,reference_filename,
              output_filename,&amp;fail,exception);
          (void) FormatLocaleFile(stdout,
            &quot;validation suite: %.17g tests; %.17g passed; %.17g failed.\n&quot;,
            (double) tests,(double) (tests-fail),(double) fail);
        }
      (void) RelinquishUniqueFileResource(output_filename);
      (void) ConcatenateMagickString(output_filename,&quot;-0&quot;,MagickPathExtent);
      (void) RelinquishUniqueFileResource(output_filename);
      (void) RelinquishUniqueFileResource(reference_filename);
    }
  if (exception-&gt;severity != UndefinedException)
    CatchException(exception);
  if (iterations &gt; 1)
    {
      elapsed_time=GetElapsedTime(timer);
      user_time=GetUserTime(timer);
      (void) FormatLocaleFile(stderr,
        &quot;Performance: %.17gi %.3fips %0.6fu %ld:%02ld.%03ld\n&quot;,(double)
        iterations,1.0*iterations/elapsed_time,user_time,(long)
        (elapsed_time/60.0),(long) ceil(fmod(elapsed_time,60.0)),
        (long) (1000.0*(elapsed_time-floor(elapsed_time))));
      timer=DestroyTimerInfo(timer);
    }
  DestroyValidate();
  MagickCoreTerminus();
  return(fail == 0 ? 0 : 1);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2FImageMagick-7.1.2-30%2Ftests'>🔙 Back</a></p>