src/net/instaweb/rewriter/image_url_encoder_test.cc - incubator-pagespeed-debian - Git at Google

 /*
  * Copyright 2012 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 // Author: poojatandon@google.com (Pooja Verlani)

 // Unit test for image_url_encoder.

 #include <set>

 #include "net/instaweb/rewriter/cached_result.pb.h"
 #include "net/instaweb/rewriter/public/image_url_encoder.h"
 #include "testing/base/public/gunit.h"
 #include "pagespeed/kernel/base/google_message_handler.h"
 #include "pagespeed/kernel/base/string.h"
 #include "pagespeed/kernel/base/string_util.h"
 #include "pagespeed/kernel/http/google_url.h"

 namespace net_instaweb {
 namespace {

 const char kDimsUrl[] = "17x33x,hencoded.url,_with,_various.stuff";
 const char kNoDimsUrl[] = "x,hencoded.url,_with,_various.stuff";
 const char kActualUrl[] = "http://encoded.url/with/various.stuff";

 }  // namespace

 class ImageUrlEncoderTest : public ::testing::Test {
  protected:
   GoogleString EncodeUrlAndDimensions(const StringPiece& origin_url,
                                       const ImageDim& dim) {
     StringVector v;
     v.push_back(origin_url.as_string());
     GoogleString out;
     ResourceContext data;
     *data.mutable_desired_image_dims() = dim;
     encoder_.Encode(v, &data, &out);
     return out;
   }

   bool DecodeUrlAndDimensions(const StringPiece& encoded,
                               ImageDim* dim,
                               GoogleString* url) {
     ResourceContext context;
     StringVector urls;
     bool result = encoder_.Decode(encoded, &urls, &context, &handler_);
     if (result) {
       EXPECT_EQ(1, urls.size());
       url->assign(urls.back());
       *dim = context.desired_image_dims();
     }
     return result;
   }

   void ExpectBadDim(const StringPiece& url) {
     GoogleString origin_url;
     ImageDim dim;
     EXPECT_FALSE(DecodeUrlAndDimensions(url, &dim, &origin_url));
     EXPECT_FALSE(ImageUrlEncoder::HasValidDimension(dim));
   }

   bool IsPagespeedWebp(StringPiece url) {
     GoogleUrl gurl(url);
     return ImageUrlEncoder::IsWebpRewrittenUrl(gurl);
   }

   ImageUrlEncoder encoder_;
   GoogleMessageHandler handler_;
 };

 TEST_F(ImageUrlEncoderTest, TestEncodingAndDecoding) {
   GoogleString kOriginalUrl = "a.jpg";
   StringVector url_vector;
   url_vector.push_back(kOriginalUrl);

   GoogleString encoded_url;

   ResourceContext context;
   context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
   context.set_mobile_user_agent(true);

   ImageDim dim;
   dim.set_width(1024);
   dim.set_height(768);
   *context.mutable_desired_image_dims() = dim;

   encoder_.Encode(url_vector, &context, &encoded_url);
   EXPECT_EQ("1024x768xa.jpg", encoded_url);

   encoder_.Decode(encoded_url, &url_vector, &context, &handler_);

   // Check the resource context returned.
   EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
   EXPECT_TRUE(context.mobile_user_agent());

   // Check the decoded url after encoding is the same as original.
   GoogleString decoded_url = url_vector.back();
   EXPECT_EQ(kOriginalUrl, decoded_url);
 }

 TEST_F(ImageUrlEncoderTest, TestEncodingAndDecodingWithoutWebpAndMobileUA) {
   GoogleString kOriginalUrl = "a.jpg";
   StringVector url_vector;
   url_vector.push_back(kOriginalUrl);

   GoogleString encoded_url;

   ResourceContext context;
   context.set_libwebp_level(ResourceContext::LIBWEBP_NONE);
   context.set_mobile_user_agent(false);

   ImageDim dim;
   dim.set_width(1024);
   dim.set_height(768);
   *context.mutable_desired_image_dims() = dim;

   encoder_.Encode(url_vector, &context, &encoded_url);
   EXPECT_EQ("1024x768xa.jpg", encoded_url);

   encoder_.Decode(encoded_url, &url_vector, &context, &handler_);

   // Check the resource context returned.
   EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_NONE);
   EXPECT_FALSE(context.mobile_user_agent());

   // Check the decoded url after encoding is the same as original.
   GoogleString decoded_url = url_vector.back();
   EXPECT_EQ(kOriginalUrl, decoded_url);
 }

 TEST_F(ImageUrlEncoderTest, TestLegacyMobileWebpDecoding) {
   StringPiece kEncodedUrl = "1024x768mwa.jpg";
   StringVector url_vector;
   ResourceContext context;

   context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
   encoder_.Decode(kEncodedUrl, &url_vector, &context, &handler_);
   EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
   EXPECT_TRUE(context.mobile_user_agent());

   GoogleString decoded_url = url_vector.back();
   EXPECT_EQ("a.jpg", decoded_url);
 }

 TEST_F(ImageUrlEncoderTest, TestLegacyMobileDecoding) {
   StringPiece kEncodedUrl = "1024x768mxa.jpg";
   StringVector url_vector;
   ResourceContext context;

   // Set webp lossy similar to the ImageRewriteFilter flow.
   context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
   encoder_.Decode(kEncodedUrl, &url_vector, &context, &handler_);
   // While decoding in ImageUrlEncoder, we don't unset libwep_level if
   // already set and no encoding char("w"/"v") is found, we get a false
   // ResourceContext, but its alright since the UA is a webp-capable one.

   EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
   EXPECT_TRUE(context.mobile_user_agent());

   GoogleString decoded_url = url_vector.back();
   EXPECT_EQ("a.jpg", decoded_url);
 }

 TEST_F(ImageUrlEncoderTest, NoDimsWebpOrMobile) {
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kNoDimsUrl, &dim, &origin_url));
   EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, NoDimsWebpLa) {
   const char kLegacyWebpLaNoMobileUrl[] = "v,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
                                      &dim, &origin_url));
   EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, NoDimsWebpLaMobile) {
   const char kLegacyWebpLaMobileUrl[] = "mv,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(
       kLegacyWebpLaMobileUrl, &dim, &origin_url));
   EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDims) {
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kDimsUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDimsWebp) {
   const char kLegacyWebpUrl[] = "17x33w,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDimsWebpLa) {
   const char kLegacyWebpLaNoMobileUrl[] =
       "17x33v,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(
       kLegacyWebpLaNoMobileUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDimsMobile) {
   const char kLegacyMobileUrl[] = "17x33mx,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyMobileUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDimsWebpMobile) {
   const char kLegacyWebpMobileUrl[] =
       "17x33mw,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpMobileUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasDimsWebpLaMobile) {
   const char kLegacyWebpLaMobileUrl[] =
       "17x33mv,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(
       kLegacyWebpLaMobileUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasWidth) {
   const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kWidthUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(-1, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasWidthWebp) {
   const char kLegacyWebpWidthUrl[] = "17xNw,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpWidthUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(-1, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
   EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasWidthWebpLa) {
   const char kLegacyWebpLaNoMobileUrl[] =
       "17xNv,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
                                      &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(17, dim.width());
   EXPECT_EQ(-1, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
   EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasHeight) {
   const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kHeightUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(-1, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   EXPECT_EQ(kHeightUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasHeightWebp) {
   const char kLegacyWebpHeightUrl[] = "Nx33w,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpHeightUrl, &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(-1, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
   EXPECT_EQ(kHeightUrl, EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, HasHeightWebpLa) {
   const char kLegacyWebpLaNoMobileUrl[] =
       "Nx33v,hencoded.url,_with,_various.stuff";
   GoogleString origin_url;
   ImageDim dim;
   EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
                                      &dim, &origin_url));
   EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
   EXPECT_EQ(-1, dim.width());
   EXPECT_EQ(33, dim.height());
   EXPECT_EQ(kActualUrl, origin_url);
   const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
   EXPECT_EQ(kHeightUrl,
             EncodeUrlAndDimensions(origin_url, dim));
 }

 TEST_F(ImageUrlEncoderTest, CacheKey) {
   ResourceContext context;

   EXPECT_EQ(".",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
   context.Clear();

   context.set_may_use_small_screen_quality(true);
   EXPECT_EQ(".ss",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
   context.Clear();

   context.set_may_use_save_data_quality(true);
   context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
   EXPECT_EQ("wd",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
   context.Clear();

   context.set_mobile_user_agent(true);
   context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_LOSSLESS_ALPHA);
   EXPECT_EQ("vm",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
   context.Clear();

   context.set_may_use_save_data_quality(true);
   context.set_mobile_user_agent(true);
   context.set_libwebp_level(ResourceContext::LIBWEBP_ANIMATED);
   EXPECT_EQ("amd",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
   context.Clear();

   // When both may_use_small_screen_quality and may_use_save_data_quality are
   // set, may_use_save_data_quality takes precedence.
   context.set_may_use_small_screen_quality(true);
   context.set_may_use_save_data_quality(true);
   EXPECT_EQ(".d",
             ImageUrlEncoder::CacheKeyFromResourceContext(context));
 }

 TEST_F(ImageUrlEncoderTest, DifferentWebpLevels) {
   // Make sure different levels of WebP support get different cache keys.
   std::set<GoogleString> seen;
   for (int webp_level = ResourceContext::LibWebpLevel_MIN;
        webp_level <= ResourceContext::LibWebpLevel_MAX;
        ++webp_level) {
     if (ResourceContext::LibWebpLevel_IsValid(webp_level)) {
       ResourceContext ctx;
       ctx.set_libwebp_level(
           static_cast<ResourceContext::LibWebpLevel>(webp_level));
       GoogleString cache_key =
           ImageUrlEncoder::CacheKeyFromResourceContext(ctx);
       EXPECT_EQ(seen.find(cache_key), seen.end());
       seen.insert(cache_key);
     }
   }
 }

 TEST_F(ImageUrlEncoderTest, BadFirst) {
   const char kBadFirst[] = "badx33x,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadFirstWebp) {
   const char kBadFirst[] = "badx33w,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadFirstWebpLa) {
   const char kBadFirst[] = "badx33v,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadFirstMobile) {
   const char kBadFirst[] = "badx33mx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadFirstWebpMobile) {
   const char kBadFirst[] = "badx33mw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadFirstWebpLaMobile) {
   const char kBadFirst[] = "badx33mv,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadFirst);
 }

 TEST_F(ImageUrlEncoderTest, BadSecond) {
   const char kBadSecond[] = "17xbadx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSecondWebp) {
   const char kBadSecond[] = "17xbadw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSecondWebpLa) {
   const char kBadSecond[] = "17xbadv,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSecondMobile) {
   const char kBadSecond[] = "17xbadmx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSecondWebpMobile) {
   const char kBadSecond[] = "17xbadmw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSecondWebpLaMobile) {
   const char kBadSecond[] = "17xbadmv,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadLeadingN) {
   const char kBadLeadingN[] = "Nxw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadLeadingN);
 }

 TEST_F(ImageUrlEncoderTest, BadMiddleN) {
   const char kBadMiddleN[] = "17xN,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadMiddleN);
 }

 TEST_F(ImageUrlEncoderTest, NoXs) {
   const char kNoXs[] = ",hencoded.url,_with,_various.stuff";
   ExpectBadDim(kNoXs);
 }

 TEST_F(ImageUrlEncoderTest, NoXsMobile) {
   const char kNoXs[] = "m,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kNoXs);
 }

 TEST_F(ImageUrlEncoderTest, BlankSecond) {
   const char kBlankSecond[] = "17xx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBlankSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadSizeCheck) {
   // Catch case where url size check was inverted.
   const char kBadSize[] = "17xx";
   ExpectBadDim(kBadSize);
 }

 TEST_F(ImageUrlEncoderTest, BlankSecondWebp) {
   const char kBlankSecond[] = "17xw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBlankSecond);
 }

 TEST_F(ImageUrlEncoderTest, BlankSecondMobile) {
   const char kBlankSecond[] = "17xmx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBlankSecond);
 }

 TEST_F(ImageUrlEncoderTest, BlankSecondWebpMobile) {
   const char kBlankSecond[] = "17xmw,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBlankSecond);
 }

 TEST_F(ImageUrlEncoderTest, BlankSecondWebpLaMobile) {
   const char kBlankSecond[] = "17xmv,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBlankSecond);
 }

 TEST_F(ImageUrlEncoderTest, BadTrailChar) {
   const char kBadDimsUrl[] = "17x33u,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadDimsUrl);
 }

 TEST_F(ImageUrlEncoderTest, BadInitChar) {
   const char kBadNoDimsUrl[] = "u,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kBadNoDimsUrl);
 }

 TEST_F(ImageUrlEncoderTest, BadWidthChar) {
   const char kWidthUrl[] = "17t,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kWidthUrl);
 }

 TEST_F(ImageUrlEncoderTest, BadHeightChar) {
   const char kHeightUrl[] = "Nx33t,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kHeightUrl);
 }

 TEST_F(ImageUrlEncoderTest, ShortBothDims) {
   const char kShortUrl[] = "17x33";
   ExpectBadDim(kShortUrl);
 }

 TEST_F(ImageUrlEncoderTest, ShortWidth) {
   const char kShortWidth[] = "Nx33";
   ExpectBadDim(kShortWidth);
 }

 TEST_F(ImageUrlEncoderTest, ShortHeight) {
   const char kShortHeight[] = "17xN";
   ExpectBadDim(kShortHeight);
 }

 TEST_F(ImageUrlEncoderTest, BothDimsMissing) {
   const char kNeitherUrl[] = "NxNx,hencoded.url,_with,_various.stuff";
   ExpectBadDim(kNeitherUrl);
 }

 TEST_F(ImageUrlEncoderTest, VeryShortUrl) {
   const char kVeryShortUrl[] = "7x3";
   ExpectBadDim(kVeryShortUrl);
 }

 TEST_F(ImageUrlEncoderTest, TruncatedAfterFirstDim) {
   const char kTruncatedUrl[] = "175x";
   ExpectBadDim(kTruncatedUrl);
 }

 TEST_F(ImageUrlEncoderTest, TruncatedBeforeSep) {
   const char kTruncatedUrl[] = "12500";
   ExpectBadDim(kTruncatedUrl);
 }

 TEST_F(ImageUrlEncoderTest, WebpDetection) {
   // Valid WebP URL.
   EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.jpg.pagespeed.ic.0.webp"));
   EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.png.pagespeed.ic.0.webp"));
   EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.gif.pagespeed.ic.0.webp"));
   EXPECT_TRUE(IsPagespeedWebp(
       "http://example.com/xa.webp.pagespeed.ic.0.webp"));
   EXPECT_TRUE(IsPagespeedWebp(
       "http://example.com/17x33a.jpg.pagespeed.ic.0.webp"));

   // Invalid WebP URL.
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/xa.jpg.XXXXXXXX.ic.0.webp"));
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/xa.gif.pagespeed.ic.0.png"));
   EXPECT_FALSE(IsPagespeedWebp(
       "http://example.com/xa.png.pagespeed.ic.0.jpeg"));
   EXPECT_FALSE(IsPagespeedWebp(
       "http://example.com/xa.jpg.pagespeed.ic.0.jpeg"));
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/foo.webp"));
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/foo.jpg"));
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/x.jpg.pagespeed.cd.0.jpeg"));
   EXPECT_FALSE(IsPagespeedWebp("http://example.com/x.jpg.pagespeed.ce.0.webp"));
 }

 }  // namespace net_instaweb
	/*
	* Copyright 2012 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	// Author: poojatandon@google.com (Pooja Verlani)

	// Unit test for image_url_encoder.

	#include <set>

	#include "net/instaweb/rewriter/cached_result.pb.h"
	#include "net/instaweb/rewriter/public/image_url_encoder.h"
	#include "testing/base/public/gunit.h"
	#include "pagespeed/kernel/base/google_message_handler.h"
	#include "pagespeed/kernel/base/string.h"
	#include "pagespeed/kernel/base/string_util.h"
	#include "pagespeed/kernel/http/google_url.h"

	namespace net_instaweb {
	namespace {

	const char kDimsUrl[] = "17x33x,hencoded.url,_with,_various.stuff";
	const char kNoDimsUrl[] = "x,hencoded.url,_with,_various.stuff";
	const char kActualUrl[] = "http://encoded.url/with/various.stuff";

	} // namespace

	class ImageUrlEncoderTest : public ::testing::Test {
	protected:
	GoogleString EncodeUrlAndDimensions(const StringPiece& origin_url,
	const ImageDim& dim) {
	StringVector v;
	v.push_back(origin_url.as_string());
	GoogleString out;
	ResourceContext data;
	*data.mutable_desired_image_dims() = dim;
	encoder_.Encode(v, &data, &out);
	return out;
	}

	bool DecodeUrlAndDimensions(const StringPiece& encoded,
	ImageDim* dim,
	GoogleString* url) {
	ResourceContext context;
	StringVector urls;
	bool result = encoder_.Decode(encoded, &urls, &context, &handler_);
	if (result) {
	EXPECT_EQ(1, urls.size());
	url->assign(urls.back());
	*dim = context.desired_image_dims();
	}
	return result;
	}

	void ExpectBadDim(const StringPiece& url) {
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_FALSE(DecodeUrlAndDimensions(url, &dim, &origin_url));
	EXPECT_FALSE(ImageUrlEncoder::HasValidDimension(dim));
	}

	bool IsPagespeedWebp(StringPiece url) {
	GoogleUrl gurl(url);
	return ImageUrlEncoder::IsWebpRewrittenUrl(gurl);
	}

	ImageUrlEncoder encoder_;
	GoogleMessageHandler handler_;
	};

	TEST_F(ImageUrlEncoderTest, TestEncodingAndDecoding) {
	GoogleString kOriginalUrl = "a.jpg";
	StringVector url_vector;
	url_vector.push_back(kOriginalUrl);

	GoogleString encoded_url;

	ResourceContext context;
	context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
	context.set_mobile_user_agent(true);

	ImageDim dim;
	dim.set_width(1024);
	dim.set_height(768);
	*context.mutable_desired_image_dims() = dim;

	encoder_.Encode(url_vector, &context, &encoded_url);
	EXPECT_EQ("1024x768xa.jpg", encoded_url);

	encoder_.Decode(encoded_url, &url_vector, &context, &handler_);

	// Check the resource context returned.
	EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
	EXPECT_TRUE(context.mobile_user_agent());

	// Check the decoded url after encoding is the same as original.
	GoogleString decoded_url = url_vector.back();
	EXPECT_EQ(kOriginalUrl, decoded_url);
	}

	TEST_F(ImageUrlEncoderTest, TestEncodingAndDecodingWithoutWebpAndMobileUA) {
	GoogleString kOriginalUrl = "a.jpg";
	StringVector url_vector;
	url_vector.push_back(kOriginalUrl);

	GoogleString encoded_url;

	ResourceContext context;
	context.set_libwebp_level(ResourceContext::LIBWEBP_NONE);
	context.set_mobile_user_agent(false);

	ImageDim dim;
	dim.set_width(1024);
	dim.set_height(768);
	*context.mutable_desired_image_dims() = dim;

	encoder_.Encode(url_vector, &context, &encoded_url);
	EXPECT_EQ("1024x768xa.jpg", encoded_url);

	encoder_.Decode(encoded_url, &url_vector, &context, &handler_);

	// Check the resource context returned.
	EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_NONE);
	EXPECT_FALSE(context.mobile_user_agent());

	// Check the decoded url after encoding is the same as original.
	GoogleString decoded_url = url_vector.back();
	EXPECT_EQ(kOriginalUrl, decoded_url);
	}

	TEST_F(ImageUrlEncoderTest, TestLegacyMobileWebpDecoding) {
	StringPiece kEncodedUrl = "1024x768mwa.jpg";
	StringVector url_vector;
	ResourceContext context;

	context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
	encoder_.Decode(kEncodedUrl, &url_vector, &context, &handler_);
	EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
	EXPECT_TRUE(context.mobile_user_agent());

	GoogleString decoded_url = url_vector.back();
	EXPECT_EQ("a.jpg", decoded_url);
	}

	TEST_F(ImageUrlEncoderTest, TestLegacyMobileDecoding) {
	StringPiece kEncodedUrl = "1024x768mxa.jpg";
	StringVector url_vector;
	ResourceContext context;

	// Set webp lossy similar to the ImageRewriteFilter flow.
	context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
	encoder_.Decode(kEncodedUrl, &url_vector, &context, &handler_);
	// While decoding in ImageUrlEncoder, we don't unset libwep_level if
	// already set and no encoding char("w"/"v") is found, we get a false
	// ResourceContext, but its alright since the UA is a webp-capable one.

	EXPECT_EQ(context.libwebp_level(), ResourceContext::LIBWEBP_LOSSY_ONLY);
	EXPECT_TRUE(context.mobile_user_agent());

	GoogleString decoded_url = url_vector.back();
	EXPECT_EQ("a.jpg", decoded_url);
	}

	TEST_F(ImageUrlEncoderTest, NoDimsWebpOrMobile) {
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kNoDimsUrl, &dim, &origin_url));
	EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, NoDimsWebpLa) {
	const char kLegacyWebpLaNoMobileUrl[] = "v,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
	&dim, &origin_url));
	EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, NoDimsWebpLaMobile) {
	const char kLegacyWebpLaMobileUrl[] = "mv,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(
	kLegacyWebpLaMobileUrl, &dim, &origin_url));
	EXPECT_FALSE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kNoDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDims) {
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kDimsUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDimsWebp) {
	const char kLegacyWebpUrl[] = "17x33w,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDimsWebpLa) {
	const char kLegacyWebpLaNoMobileUrl[] =
	"17x33v,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(
	kLegacyWebpLaNoMobileUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDimsMobile) {
	const char kLegacyMobileUrl[] = "17x33mx,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyMobileUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDimsWebpMobile) {
	const char kLegacyWebpMobileUrl[] =
	"17x33mw,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpMobileUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasDimsWebpLaMobile) {
	const char kLegacyWebpLaMobileUrl[] =
	"17x33mv,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(
	kLegacyWebpLaMobileUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimensions(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kDimsUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasWidth) {
	const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kWidthUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(-1, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasWidthWebp) {
	const char kLegacyWebpWidthUrl[] = "17xNw,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpWidthUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(-1, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
	EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasWidthWebpLa) {
	const char kLegacyWebpLaNoMobileUrl[] =
	"17xNv,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
	&dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(17, dim.width());
	EXPECT_EQ(-1, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	const char kWidthUrl[] = "17xNx,hencoded.url,_with,_various.stuff";
	EXPECT_EQ(kWidthUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasHeight) {
	const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kHeightUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(-1, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	EXPECT_EQ(kHeightUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasHeightWebp) {
	const char kLegacyWebpHeightUrl[] = "Nx33w,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpHeightUrl, &dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(-1, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
	EXPECT_EQ(kHeightUrl, EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, HasHeightWebpLa) {
	const char kLegacyWebpLaNoMobileUrl[] =
	"Nx33v,hencoded.url,_with,_various.stuff";
	GoogleString origin_url;
	ImageDim dim;
	EXPECT_TRUE(DecodeUrlAndDimensions(kLegacyWebpLaNoMobileUrl,
	&dim, &origin_url));
	EXPECT_TRUE(ImageUrlEncoder::HasValidDimension(dim));
	EXPECT_EQ(-1, dim.width());
	EXPECT_EQ(33, dim.height());
	EXPECT_EQ(kActualUrl, origin_url);
	const char kHeightUrl[] = "Nx33x,hencoded.url,_with,_various.stuff";
	EXPECT_EQ(kHeightUrl,
	EncodeUrlAndDimensions(origin_url, dim));
	}

	TEST_F(ImageUrlEncoderTest, CacheKey) {
	ResourceContext context;

	EXPECT_EQ(".",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	context.Clear();

	context.set_may_use_small_screen_quality(true);
	EXPECT_EQ(".ss",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	context.Clear();

	context.set_may_use_save_data_quality(true);
	context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_ONLY);
	EXPECT_EQ("wd",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	context.Clear();

	context.set_mobile_user_agent(true);
	context.set_libwebp_level(ResourceContext::LIBWEBP_LOSSY_LOSSLESS_ALPHA);
	EXPECT_EQ("vm",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	context.Clear();

	context.set_may_use_save_data_quality(true);
	context.set_mobile_user_agent(true);
	context.set_libwebp_level(ResourceContext::LIBWEBP_ANIMATED);
	EXPECT_EQ("amd",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	context.Clear();

	// When both may_use_small_screen_quality and may_use_save_data_quality are
	// set, may_use_save_data_quality takes precedence.
	context.set_may_use_small_screen_quality(true);
	context.set_may_use_save_data_quality(true);
	EXPECT_EQ(".d",
	ImageUrlEncoder::CacheKeyFromResourceContext(context));
	}

	TEST_F(ImageUrlEncoderTest, DifferentWebpLevels) {
	// Make sure different levels of WebP support get different cache keys.
	std::set<GoogleString> seen;
	for (int webp_level = ResourceContext::LibWebpLevel_MIN;
	webp_level <= ResourceContext::LibWebpLevel_MAX;
	++webp_level) {
	if (ResourceContext::LibWebpLevel_IsValid(webp_level)) {
	ResourceContext ctx;
	ctx.set_libwebp_level(
	static_cast<ResourceContext::LibWebpLevel>(webp_level));
	GoogleString cache_key =
	ImageUrlEncoder::CacheKeyFromResourceContext(ctx);
	EXPECT_EQ(seen.find(cache_key), seen.end());
	seen.insert(cache_key);
	}
	}
	}

	TEST_F(ImageUrlEncoderTest, BadFirst) {
	const char kBadFirst[] = "badx33x,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadFirstWebp) {
	const char kBadFirst[] = "badx33w,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadFirstWebpLa) {
	const char kBadFirst[] = "badx33v,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadFirstMobile) {
	const char kBadFirst[] = "badx33mx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadFirstWebpMobile) {
	const char kBadFirst[] = "badx33mw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadFirstWebpLaMobile) {
	const char kBadFirst[] = "badx33mv,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadFirst);
	}

	TEST_F(ImageUrlEncoderTest, BadSecond) {
	const char kBadSecond[] = "17xbadx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSecondWebp) {
	const char kBadSecond[] = "17xbadw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSecondWebpLa) {
	const char kBadSecond[] = "17xbadv,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSecondMobile) {
	const char kBadSecond[] = "17xbadmx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSecondWebpMobile) {
	const char kBadSecond[] = "17xbadmw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSecondWebpLaMobile) {
	const char kBadSecond[] = "17xbadmv,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadLeadingN) {
	const char kBadLeadingN[] = "Nxw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadLeadingN);
	}

	TEST_F(ImageUrlEncoderTest, BadMiddleN) {
	const char kBadMiddleN[] = "17xN,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadMiddleN);
	}

	TEST_F(ImageUrlEncoderTest, NoXs) {
	const char kNoXs[] = ",hencoded.url,_with,_various.stuff";
	ExpectBadDim(kNoXs);
	}

	TEST_F(ImageUrlEncoderTest, NoXsMobile) {
	const char kNoXs[] = "m,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kNoXs);
	}

	TEST_F(ImageUrlEncoderTest, BlankSecond) {
	const char kBlankSecond[] = "17xx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBlankSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadSizeCheck) {
	// Catch case where url size check was inverted.
	const char kBadSize[] = "17xx";
	ExpectBadDim(kBadSize);
	}

	TEST_F(ImageUrlEncoderTest, BlankSecondWebp) {
	const char kBlankSecond[] = "17xw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBlankSecond);
	}

	TEST_F(ImageUrlEncoderTest, BlankSecondMobile) {
	const char kBlankSecond[] = "17xmx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBlankSecond);
	}

	TEST_F(ImageUrlEncoderTest, BlankSecondWebpMobile) {
	const char kBlankSecond[] = "17xmw,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBlankSecond);
	}

	TEST_F(ImageUrlEncoderTest, BlankSecondWebpLaMobile) {
	const char kBlankSecond[] = "17xmv,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBlankSecond);
	}

	TEST_F(ImageUrlEncoderTest, BadTrailChar) {
	const char kBadDimsUrl[] = "17x33u,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadDimsUrl);
	}

	TEST_F(ImageUrlEncoderTest, BadInitChar) {
	const char kBadNoDimsUrl[] = "u,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kBadNoDimsUrl);
	}

	TEST_F(ImageUrlEncoderTest, BadWidthChar) {
	const char kWidthUrl[] = "17t,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kWidthUrl);
	}

	TEST_F(ImageUrlEncoderTest, BadHeightChar) {
	const char kHeightUrl[] = "Nx33t,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kHeightUrl);
	}

	TEST_F(ImageUrlEncoderTest, ShortBothDims) {
	const char kShortUrl[] = "17x33";
	ExpectBadDim(kShortUrl);
	}

	TEST_F(ImageUrlEncoderTest, ShortWidth) {
	const char kShortWidth[] = "Nx33";
	ExpectBadDim(kShortWidth);
	}

	TEST_F(ImageUrlEncoderTest, ShortHeight) {
	const char kShortHeight[] = "17xN";
	ExpectBadDim(kShortHeight);
	}

	TEST_F(ImageUrlEncoderTest, BothDimsMissing) {
	const char kNeitherUrl[] = "NxNx,hencoded.url,_with,_various.stuff";
	ExpectBadDim(kNeitherUrl);
	}

	TEST_F(ImageUrlEncoderTest, VeryShortUrl) {
	const char kVeryShortUrl[] = "7x3";
	ExpectBadDim(kVeryShortUrl);
	}

	TEST_F(ImageUrlEncoderTest, TruncatedAfterFirstDim) {
	const char kTruncatedUrl[] = "175x";
	ExpectBadDim(kTruncatedUrl);
	}

	TEST_F(ImageUrlEncoderTest, TruncatedBeforeSep) {
	const char kTruncatedUrl[] = "12500";
	ExpectBadDim(kTruncatedUrl);
	}

	TEST_F(ImageUrlEncoderTest, WebpDetection) {
	// Valid WebP URL.
	EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.jpg.pagespeed.ic.0.webp"));
	EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.png.pagespeed.ic.0.webp"));
	EXPECT_TRUE(IsPagespeedWebp("http://example.com/xa.gif.pagespeed.ic.0.webp"));
	EXPECT_TRUE(IsPagespeedWebp(
	"http://example.com/xa.webp.pagespeed.ic.0.webp"));
	EXPECT_TRUE(IsPagespeedWebp(
	"http://example.com/17x33a.jpg.pagespeed.ic.0.webp"));

	// Invalid WebP URL.
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/xa.jpg.XXXXXXXX.ic.0.webp"));
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/xa.gif.pagespeed.ic.0.png"));
	EXPECT_FALSE(IsPagespeedWebp(
	"http://example.com/xa.png.pagespeed.ic.0.jpeg"));
	EXPECT_FALSE(IsPagespeedWebp(
	"http://example.com/xa.jpg.pagespeed.ic.0.jpeg"));
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/foo.webp"));
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/foo.jpg"));
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/x.jpg.pagespeed.cd.0.jpeg"));
	EXPECT_FALSE(IsPagespeedWebp("http://example.com/x.jpg.pagespeed.ce.0.webp"));
	}

	} // namespace net_instaweb