remoting/base/util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6
   7 #include "remoting/base/util.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  10
  11 static const int kWidth = 32 ;
  12 static const int kHeight = 24 ;
  13 static const int kBytesPerPixel = 4;
  14 static const int kYStride = kWidth;
  15 static const int kUvStride = kWidth / 2;
  16 static const int kRgbStride = kWidth * kBytesPerPixel;
  17 static const uint32 kFillColor = 0xffffff;
  18
  19 namespace remoting {
  20
  21 class YuvToRgbTester {
  22  public:
  23   YuvToRgbTester() {
  24     yuv_buffer_size_ = (kYStride + kUvStride) * kHeight;
  25     yuv_buffer_.reset(new uint8[yuv_buffer_size_]);
  26     yplane_ = yuv_buffer_.get();
  27     uplane_ = yplane_ + (kYStride * kHeight);
  28     vplane_ = uplane_ + (kUvStride * kHeight / 2);
  29
  30     rgb_buffer_size_ = kWidth * kHeight * kBytesPerPixel;
  31     rgb_buffer_.reset(new uint8[rgb_buffer_size_]);
  32
  33     ResetYuvBuffer();
  34     ResetRgbBuffer();
  35   }
  36
  37   ~YuvToRgbTester() {}
  38
  39   void ResetYuvBuffer() {
  40     memset(yuv_buffer_.get(), 0, yuv_buffer_size_);
  41   }
  42
  43   void ResetRgbBuffer() {
  44     memset(rgb_buffer_.get(), 0, rgb_buffer_size_);
  45   }
  46
  47   void FillRgbBuffer(const webrtc::DesktopRect& rect) {
  48     uint32* ptr = reinterpret_cast<uint32*>(
  49         rgb_buffer_.get() + (rect.top() * kRgbStride) +
  50         (rect.left() * kBytesPerPixel));
  51     int width = rect.width();
  52     for (int height = rect.height(); height > 0; --height) {
  53       std::fill(ptr, ptr + width, kFillColor);
  54       ptr += kRgbStride / kBytesPerPixel;
  55     }
  56   }
  57
  58   // Check the the desination buffer is filled within expected bounds.
  59   void  CheckRgbBuffer(const webrtc::DesktopRect& rect) {
  60     uint32* ptr = reinterpret_cast<uint32*>(rgb_buffer_.get());
  61     for (int y = 0; y < kHeight; ++y) {
  62       if (y < rect.top() || rect.bottom() <= y) {
  63         // The whole line should be intact.
  64         EXPECT_EQ((ptrdiff_t)kWidth,
  65                   std::count(ptr, ptr + kWidth, 0u));
  66       } else {
  67         // The space before the painted rectangle should be intact.
  68         EXPECT_EQ((ptrdiff_t)rect.left(),
  69                   std::count(ptr, ptr + rect.left(), 0u));
  70
  71         // All pixels of the target rectangle should be touched.
  72         EXPECT_EQ(ptr + rect.right(),
  73                   std::find(ptr + rect.left(), ptr + rect.right(), 0u));
  74
  75         // The space after the painted rectangle should be intact.
  76         EXPECT_EQ((ptrdiff_t)kWidth - rect.right(),
  77                   std::count(ptr + rect.right(), ptr + kWidth, 0u));
  78       }
  79       ptr += kRgbStride / kBytesPerPixel;
  80     }
  81   }
  82
  83   void RunTest(const webrtc::DesktopSize dest_size,
  84                const webrtc::DesktopRect& rect) {
  85     ASSERT_TRUE(
  86         DoesRectContain(webrtc::DesktopRect::MakeSize(dest_size), rect));
  87
  88     // Reset buffers.
  89     ResetYuvBuffer();
  90     ResetRgbBuffer();
  91     FillRgbBuffer(rect);
  92
  93     // RGB -> YUV
  94     ConvertRGB32ToYUVWithRect(rgb_buffer_.get(),
  95                               yplane_,
  96                               uplane_,
  97                               vplane_,
  98                               0,
  99                               0,
 100                               kWidth,
 101                               kHeight,
 102                               kRgbStride,
 103                               kYStride,
 104                               kUvStride);
 105
 106     // Reset RGB buffer and do opposite conversion.
 107     ResetRgbBuffer();
 108     ConvertAndScaleYUVToRGB32Rect(yplane_,
 109                                   uplane_,
 110                                   vplane_,
 111                                   kYStride,
 112                                   kUvStride,
 113                                   webrtc::DesktopSize(kWidth, kHeight),
 114                                   webrtc::DesktopRect::MakeWH(kWidth, kHeight),
 115                                   rgb_buffer_.get(),
 116                                   kRgbStride,
 117                                   dest_size,
 118                                   webrtc::DesktopRect::MakeSize(dest_size),
 119                                   rect);
 120
 121     // Check if it worked out.
 122     CheckRgbBuffer(rect);
 123   }
 124
 125   void TestBasicConversion() {
 126     // Whole buffer.
 127     RunTest(webrtc::DesktopSize(kWidth, kHeight),
 128             webrtc::DesktopRect::MakeWH(kWidth, kHeight));
 129   }
 130
 131  private:
 132   size_t yuv_buffer_size_;
 133   scoped_ptr<uint8[]> yuv_buffer_;
 134   uint8* yplane_;
 135   uint8* uplane_;
 136   uint8* vplane_;
 137
 138   size_t rgb_buffer_size_;
 139   scoped_ptr<uint8[]> rgb_buffer_;
 140
 141   DISALLOW_COPY_AND_ASSIGN(YuvToRgbTester);
 142 };
 143
 144 TEST(YuvToRgbTest, BasicConversion) {
 145   YuvToRgbTester tester;
 146   tester.TestBasicConversion();
 147 }
 148
 149 TEST(YuvToRgbTest, Clipping) {
 150   YuvToRgbTester tester;
 151
 152   webrtc::DesktopSize dest_size = webrtc::DesktopSize(kWidth, kHeight);
 153   webrtc::DesktopRect rect =
 154       webrtc::DesktopRect::MakeLTRB(0, 0, kWidth - 1, kHeight - 1);
 155   // TODO(fbarchard): Allow top/left clipping to odd boundary.
 156   for (int i = 0; i < 16; ++i) {
 157     webrtc::DesktopRect dest_rect = webrtc::DesktopRect::MakeLTRB(
 158         rect.left() + ((i & 1) ? 2 : 0),
 159         rect.top() + ((i & 2) ? 2 : 0),
 160         rect.right() - ((i & 4) ? 1 : 0),
 161         rect.bottom() - ((i & 8) ? 1 : 0));
 162
 163     tester.RunTest(dest_size, dest_rect);
 164   }
 165 }
 166
 167 TEST(YuvToRgbTest, ClippingAndScaling) {
 168   YuvToRgbTester tester;
 169
 170   webrtc::DesktopSize dest_size =
 171       webrtc::DesktopSize(kWidth - 10, kHeight - 10);
 172   webrtc::DesktopRect rect =
 173       webrtc::DesktopRect::MakeLTRB(6, 6, kWidth - 11, kHeight - 11);
 174   for (int i = 0; i < 16; ++i) {
 175     webrtc::DesktopRect dest_rect = webrtc::DesktopRect::MakeLTRB(
 176         rect.left() + ((i & 1) ? 2 : 0),
 177         rect.top() + ((i & 2) ? 2 : 0),
 178         rect.right() - ((i & 4) ? 1 : 0),
 179         rect.bottom() - ((i & 8) ? 1 : 0));
 180
 181     tester.RunTest(dest_size, dest_rect);
 182   }
 183 }
 184
 185 TEST(ReplaceLfByCrLfTest, Basic) {
 186   EXPECT_EQ("ab", ReplaceLfByCrLf("ab"));
 187   EXPECT_EQ("\r\nab", ReplaceLfByCrLf("\nab"));
 188   EXPECT_EQ("\r\nab\r\n", ReplaceLfByCrLf("\nab\n"));
 189   EXPECT_EQ("\r\nab\r\ncd", ReplaceLfByCrLf("\nab\ncd"));
 190   EXPECT_EQ("\r\nab\r\ncd\r\n", ReplaceLfByCrLf("\nab\ncd\n"));
 191   EXPECT_EQ("\r\n\r\nab\r\n\r\ncd\r\n\r\n",
 192       ReplaceLfByCrLf("\n\nab\n\ncd\n\n"));
 193 }
 194
 195 TEST(ReplaceLfByCrLfTest, Speed) {
 196   int kLineSize = 128;
 197   std::string line(kLineSize, 'a');
 198   line[kLineSize - 1] = '\n';
 199   // Make a 10M string.
 200   int kLineNum = 10 * 1024 * 1024 / kLineSize;
 201   std::string buffer;
 202   buffer.resize(kLineNum * kLineSize);
 203   for (int i = 0; i < kLineNum; ++i) {
 204     memcpy(&buffer[i * kLineSize], &line[0], kLineSize);
 205   }
 206   // Convert the string.
 207   buffer = ReplaceLfByCrLf(buffer);
 208   // Check the converted string.
 209   EXPECT_EQ(static_cast<size_t>((kLineSize + 1) * kLineNum), buffer.size());
 210   const char* p = &buffer[0];
 211   for (int i = 0; i < kLineNum; ++i) {
 212     EXPECT_EQ(0, memcmp(&line[0], p, kLineSize - 1));
 213     p += kLineSize - 1;
 214     EXPECT_EQ('\r', *p++);
 215     EXPECT_EQ('\n', *p++);
 216   }
 217 }
 218
 219 TEST(ReplaceCrLfByLfTest, Basic) {
 220   EXPECT_EQ("ab", ReplaceCrLfByLf("ab"));
 221   EXPECT_EQ("\nab", ReplaceCrLfByLf("\r\nab"));
 222   EXPECT_EQ("\nab\n", ReplaceCrLfByLf("\r\nab\r\n"));
 223   EXPECT_EQ("\nab\ncd", ReplaceCrLfByLf("\r\nab\r\ncd"));
 224   EXPECT_EQ("\nab\ncd\n", ReplaceCrLfByLf("\r\nab\r\ncd\n"));
 225   EXPECT_EQ("\n\nab\n\ncd\n\n",
 226       ReplaceCrLfByLf("\r\n\r\nab\r\n\r\ncd\r\n\r\n"));
 227   EXPECT_EQ("\rab\rcd\r", ReplaceCrLfByLf("\rab\rcd\r"));
 228 }
 229
 230 TEST(ReplaceCrLfByLfTest, Speed) {
 231   int kLineSize = 128;
 232   std::string line(kLineSize, 'a');
 233   line[kLineSize - 2] = '\r';
 234   line[kLineSize - 1] = '\n';
 235   // Make a 10M string.
 236   int kLineNum = 10 * 1024 * 1024 / kLineSize;
 237   std::string buffer;
 238   buffer.resize(kLineNum * kLineSize);
 239   for (int i = 0; i < kLineNum; ++i) {
 240     memcpy(&buffer[i * kLineSize], &line[0], kLineSize);
 241   }
 242   // Convert the string.
 243   buffer = ReplaceCrLfByLf(buffer);
 244   // Check the converted string.
 245   EXPECT_EQ(static_cast<size_t>((kLineSize - 1) * kLineNum), buffer.size());
 246   const char* p = &buffer[0];
 247   for (int i = 0; i < kLineNum; ++i) {
 248     EXPECT_EQ(0, memcmp(&line[0], p, kLineSize - 2));
 249     p += kLineSize - 2;
 250     EXPECT_EQ('\n', *p++);
 251   }
 252 }
 253
 254 TEST(StringIsUtf8Test, Basic) {
 255   EXPECT_TRUE(StringIsUtf8("", 0));
 256   EXPECT_TRUE(StringIsUtf8("\0", 1));
 257   EXPECT_TRUE(StringIsUtf8("abc", 3));
 258   EXPECT_TRUE(StringIsUtf8("\xc0\x80", 2));
 259   EXPECT_TRUE(StringIsUtf8("\xe0\x80\x80", 3));
 260   EXPECT_TRUE(StringIsUtf8("\xf0\x80\x80\x80", 4));
 261   EXPECT_TRUE(StringIsUtf8("\xf8\x80\x80\x80\x80", 5));
 262   EXPECT_TRUE(StringIsUtf8("\xfc\x80\x80\x80\x80\x80", 6));
 263
 264   // Not enough continuation characters
 265   EXPECT_FALSE(StringIsUtf8("\xc0", 1));
 266   EXPECT_FALSE(StringIsUtf8("\xe0\x80", 2));
 267   EXPECT_FALSE(StringIsUtf8("\xf0\x80\x80", 3));
 268   EXPECT_FALSE(StringIsUtf8("\xf8\x80\x80\x80", 4));
 269   EXPECT_FALSE(StringIsUtf8("\xfc\x80\x80\x80\x80", 5));
 270
 271   // One more continuation character than needed
 272   EXPECT_FALSE(StringIsUtf8("\xc0\x80\x80", 3));
 273   EXPECT_FALSE(StringIsUtf8("\xe0\x80\x80\x80", 4));
 274   EXPECT_FALSE(StringIsUtf8("\xf0\x80\x80\x80\x80", 5));
 275   EXPECT_FALSE(StringIsUtf8("\xf8\x80\x80\x80\x80\x80", 6));
 276   EXPECT_FALSE(StringIsUtf8("\xfc\x80\x80\x80\x80\x80\x80", 7));
 277
 278   // Invalid first byte
 279   EXPECT_FALSE(StringIsUtf8("\xfe\x80\x80\x80\x80\x80\x80", 7));
 280   EXPECT_FALSE(StringIsUtf8("\xff\x80\x80\x80\x80\x80\x80", 7));
 281
 282   // Invalid continuation byte
 283   EXPECT_FALSE(StringIsUtf8("\xc0\x00", 2));
 284   EXPECT_FALSE(StringIsUtf8("\xc0\x40", 2));
 285   EXPECT_FALSE(StringIsUtf8("\xc0\xc0", 2));
 286 }
 287
 288 }  // namespace remoting