Snap for 10453563 from 36c1161394b5326928858d2db709ba7ef6759932 to mainline-permission-releaseaml_per_341614000aml_per_341510010aml_per_341410020aml_per_341311000aml_per_341110020aml_per_341110010aml_per_341011100aml_per_341011020aml_per_340916010android14-mainline-permission-release

Change-Id: Icda0895c4c50e28d5af65ce4cf4e7597290a7a08

14 files changed, 379 insertions, 319 deletions

diff --git a/OWNERS b/OWNERS
index 03d84b8..5b6cb14 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,4 +1,4 @@
+mikemcternan@google.com
 jbires@google.com
-jdanis@google.com
 swillden@google.com
 zeuthen@google.com
diff --git a/libteeui/include/teeui/font_rendering.h b/libteeui/include/teeui/font_rendering.h
index a19dc51..32fbc49 100644
--- a/libteeui/include/teeui/font_rendering.h
+++ b/libteeui/include/teeui/font_rendering.h
@@ -77,6 +77,7 @@ MAP_HANDLE_DELETER(FT_Library, FT_Done_FreeType);
 
 
 bool isBreakable(unsigned long codePoint);
+bool isNewline(unsigned long codePoint);
 
 template <typename CharIterator> class UTF8WordRange {
     UTF8Range<CharIterator> range_;
diff --git a/libteeui/include/teeui/label.h b/libteeui/include/teeui/label.h
index 845922a..6c7b3d0 100644
--- a/libteeui/include/teeui/label.h
+++ b/libteeui/include/teeui/label.h
@@ -147,11 +147,14 @@ template <typename Derived> class Label : public LayoutElement<Derived>, public
 #define HorizontalTextAlignment(horizontalAligment)                                                \
     static const constexpr Alignment label_horizontal_text_alignment = horizontalAligment;
 
+#define LeftJustified HorizontalTextAlignment(Alignment::LEFT)
+#define CenterJustified HorizontalTextAlignment(Alignment::CENTER)
 #define RightJustified HorizontalTextAlignment(Alignment::RIGHT)
 
 #define VerticalTextAlignment(verticalAligment)                                                    \
     static const constexpr Alignment label_vertical_text_alignment = verticalAligment;
 
+#define VerticallyTop VerticalTextAlignment(Alignment::TOP)
 #define VerticallyCentered VerticalTextAlignment(Alignment::CENTER)
 
 #define TextColor(color) static const constexpr auto label_text_color = color
diff --git a/libteeui/include/teeui/utf8range.h b/libteeui/include/teeui/utf8range.h
index 496b903..5fe27ff 100644
--- a/libteeui/include/teeui/utf8range.h
+++ b/libteeui/include/teeui/utf8range.h
@@ -61,7 +61,7 @@ template <typename CharIterator> class UTF8Range {
             return c;
         } else {
             // multi byte
-            unsigned long result = c & ~(0xff << (8 - byte_count));
+            unsigned long result = c & ~(0xffu << (8 - byte_count));
             ++begin;
             for (size_t i = 1; i < byte_count; ++i) {
                 result <<= 6;
diff --git a/libteeui/include/teeui/utils.h b/libteeui/include/teeui/utils.h
index 985761a..e52c6eb 100644
--- a/libteeui/include/teeui/utils.h
+++ b/libteeui/include/teeui/utils.h
@@ -458,6 +458,11 @@ class context<MetaList<MetaParam<ParamsNames, ParamTypes>...>, Numeric> {
     };
 
   public:
+    explicit context(Numeric mm2px) {
+        mm2px_ = mm2px;
+        dp2px_ = (mm2px * 25.4) / 160.0; /* 1dp = 1/160th of an inch */
+    }
+
     context(Numeric mm2px, Numeric dp2px) : mm2px_(mm2px), dp2px_(dp2px) {}
 
     context(const context&) = default;
diff --git a/libteeui/src/font_rendering.cpp b/libteeui/src/font_rendering.cpp
index 49c4847..8f96066 100644
--- a/libteeui/src/font_rendering.cpp
+++ b/libteeui/src/font_rendering.cpp
@@ -53,6 +53,10 @@ bool isBreakable(unsigned long codePoint) {
     }
 }
 
+bool isNewline(unsigned long codePoint) {
+    return codePoint == '\n';
+}
+
 Error TextFace::setCharSize(signed long char_size, unsigned int dpi) {
     if (!face_) return Error::NotInitialized;
     auto error = FT_Set_Char_Size(*face_, 0, char_size, 0, dpi);
diff --git a/libteeui/src/label.cpp b/libteeui/src/label.cpp
index 34d8eb0..6dfd8f7 100644
--- a/libteeui/src/label.cpp
+++ b/libteeui/src/label.cpp
@@ -69,10 +69,21 @@ Error LabelImpl::draw(const PixelDrawer& drawPixel, const Box<pxs>& bounds, Line
 
     auto curLine = lineInfo->begin();
     while (textBegin != text_.end()) {
-        if (curLine == lineInfo->end()) return Error::OutOfMemory;
+        if (curLine == lineInfo->end()) {
+            TEEUI_LOG << "lineInfo filled: lines=" << lineInfo->size_ << " textId=" << textId_
+                      << ENDL;
+            return Error::OutOfMemory;
+        }
+
+        auto lineEnd = textBegin;
+
+        while (!isNewline(lineEnd.codePoint()) && lineEnd != text_.end()) {
+            lineEnd++;
+        }
+
         Box<pxs> bBox;
         std::tie(error, bBox, curLine->lineText) =
-            findLongestWordSequence(&face, text_t(*textBegin, *text_.end()), bounds);
+            findLongestWordSequence(&face, text_t(*textBegin, *lineEnd), bounds);
         if (error) return error;
 
         pen = {-bBox.x(), pen.y()};
@@ -99,7 +110,12 @@ Error LabelImpl::draw(const PixelDrawer& drawPixel, const Box<pxs>& bounds, Line
         else
             boundingBox = bBox;
 
+        // Set start position for next loop, skipping a newline if found
         textBegin = curLine->lineText.end();
+        if (isNewline(textBegin.codePoint())) {
+            textBegin++;
+        }
+
         pen += {0_px, lineHeight_};
         ++curLine;
     }
diff --git a/test/example_config/README b/test/example_config/README
index 5e4f63c..f841fcf 100644
--- a/test/example_config/README
+++ b/test/example_config/README
@@ -72,6 +72,9 @@ provided, the values will default to the values for Blueline.
           },
           {
             "native-test-flag": "--volUpButtonBottom=<distance from the bottom of the UP power button to the top of the screen in mm>"
+          },
+          {
+             "native-test-flag": "--saveScreen"
           }
         ]
     }
diff --git a/test/include/teeui/test/teeui_render_test.h b/test/include/teeui/test/teeui_render_test.h
index cc28afd..b8f1de2 100644
--- a/test/include/teeui/test/teeui_render_test.h
+++ b/test/include/teeui/test/teeui_render_test.h
@@ -23,7 +23,7 @@ namespace test {
 // Initializes the test with the device configuration with command line params.
 extern void initRenderTest(int argc, char** argv);
 
-extern int runRenderTest(const char* language, bool magnified, bool inverted = false,
+extern int runRenderTest(const char* language, bool magnified, bool inverted,
                          const char* confirmationMessage = "", const char* layout = "");
 
 }  // namespace test
diff --git a/test/teeui_device_config.cpp b/test/teeui_device_config.cpp
index ff8bf71..9e043e7 100644
--- a/test/teeui_device_config.cpp
+++ b/test/teeui_device_config.cpp
@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 
+#include <fstream>
 #include <getopt.h>
 #include <gtest/gtest.h>
+#include <inttypes.h>
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>
@@ -37,6 +39,39 @@ void initRenderTest(int argc, char** argv) {
     ::teeui::test::TeeuiRenderTest::Instance()->initFromOptions(argc, argv);
 }
 
+void saveToPpm(const uint32_t* data, uint32_t w, uint32_t h, uint32_t linestride) {
+    const testing::TestInfo* const test_info =
+        testing::UnitTest::GetInstance()->current_test_info();
+    std::string testname = test_info->name();
+    std::ofstream out;
+
+    out.open(testname + ".ppm", std::ios::binary);
+    if (out.is_open()) {
+        uint32_t linestart = 0;
+
+        /* Write the header */
+        out << "P6\n" << w << " " << h << "\n255\n";
+
+        /* Write binary Pixel data */
+        for (uint32_t line = 0; line < h; line++) {
+            for (uint32_t col = 0; col < w; col++) {
+                const uint32_t color = data[linestart + col];
+                char rgb[3];
+
+                rgb[0] = color >> 16;
+                rgb[1] = color >> 8;
+                rgb[2] = color;
+
+                out.write(rgb, sizeof(rgb));
+            }
+
+            linestart += linestride;
+        }
+
+        out.close();
+    }
+}
+
 int runRenderTest(const char* language, bool magnified, bool inverted,
                   const char* confirmationMessage, const char* layout) {
     std::unique_ptr<ITeeuiExample> sCurrentExample = createExample(
@@ -54,40 +89,16 @@ int runRenderTest(const char* language, bool magnified, bool inverted,
 
     int error =
         sCurrentExample->renderUIIntoBuffer(0, 0, w, h, linestride, buffer.data(), buffer_size);
-    return error;
-}
 
-/*
- * Configures device with test parameters
- * widthPx, heightPx : pixel dimension of devices
- * dp2px : density pixel to pixel
- * mm2px : millimeter to pixel
- * powerButtonTopMm : location of the top of the power button in mm
- * powerButtonBottomMm : location of the bottom of the power button in mm
- * volUpButtonTopMm : location of the top of the up volume button in mm
- * volUpButtonBottomMm : location of the bottom of the up power button in mm
- */
-void TeeuiRenderTest::createDevice(int widthPx, int heightPx, double dp2px, double mm2px,
-                                   double powerButtonTopMm, double powerButtonBottomMm,
-                                   double volUpButtonTopMm, double volUpButtonBottomMm) {
-    DeviceInfo* device_info_ptr = &TeeuiRenderTest::Instance()->device_info;
-    device_info_ptr->width_ = widthPx;
-    device_info_ptr->height_ = heightPx;
-    device_info_ptr->dp2px_ = dp2px;
-    device_info_ptr->mm2px_ = mm2px;
-    device_info_ptr->powerButtonTopMm_ = powerButtonTopMm;
-    device_info_ptr->powerButtonBottomMm_ = powerButtonBottomMm;
-    device_info_ptr->volUpButtonTopMm_ = volUpButtonTopMm;
-    device_info_ptr->volUpButtonBottomMm_ = volUpButtonBottomMm;
+    if (TeeuiRenderTest::Instance()->saveScreen()) {
+        saveToPpm(buffer.data(), w, h, linestride);
+    }
+
+    return error;
 }
 
 void TeeuiRenderTest::initFromOptions(int argc, char** argv) {
 
-    uint width = 0, height = 0;
-    double dp2px = 0, mm2px = 0;
-    double powerBottonTopMm = 0, powerButtonBottomMm = 0;
-    double volUpButtonTopMm = 0, volUpButtonBottomMm = 0;
-
     int option_index = 0;
     static struct option options[] = {{"width", required_argument, 0, 'w'},
                                       {"height", required_argument, 0, 'l'},
@@ -97,43 +108,40 @@ void TeeuiRenderTest::initFromOptions(int argc, char** argv) {
                                       {"powerButtonBottom", required_argument, 0, 'b'},
                                       {"volUpButtonTop", required_argument, 0, 'u'},
                                       {"volUpButtonBottom", required_argument, 0, 'v'},
+                                      {"saveScreen", 0, 0, 's'},
                                       {"help", 0, 0, 'h'},
                                       {"?", 0, 0, '?'},
                                       {0, 0, 0, 0}};
     while (true) {
         int c = getopt_long(argc, argv, "w:l:d:m:t:b:u:v:h?", options, &option_index);
         if (c == -1) break;
-        double numeric_value = 0;
         switch (c) {
         case 'w':
-            width = atoi(optarg);
+            device_info.width_ = strtol(optarg, NULL, 10);
             break;
         case 'l':
-            height = atoi(optarg);
+            device_info.height_ = strtol(optarg, NULL, 10);
             break;
         case 'd':
-            numeric_value = strtod(optarg, NULL);
-            dp2px = numeric_value;
+            device_info.dp2px_ = strtod(optarg, NULL);
             break;
         case 'm':
-            numeric_value = strtod(optarg, NULL);
-            mm2px = numeric_value;
+            device_info.mm2px_ = strtod(optarg, NULL);
             break;
         case 't':
-            numeric_value = strtod(optarg, NULL);
-            powerBottonTopMm = numeric_value;
+            device_info.powerButtonTopMm_ = strtod(optarg, NULL);
             break;
         case 'b':
-            numeric_value = strtod(optarg, NULL);
-            powerButtonBottomMm = numeric_value;
+            device_info.powerButtonBottomMm_ = strtod(optarg, NULL);
             break;
         case 'u':
-            numeric_value = strtod(optarg, NULL);
-            volUpButtonTopMm = numeric_value;
+            device_info.volUpButtonTopMm_ = strtod(optarg, NULL);
             break;
         case 'v':
-            numeric_value = strtod(optarg, NULL);
-            volUpButtonBottomMm = numeric_value;
+            device_info.volUpButtonBottomMm_ = strtod(optarg, NULL);
+            break;
+        case 's':
+            saveScreen_ = true;
             break;
         case '?':
         case 'h':
@@ -156,11 +164,11 @@ void TeeuiRenderTest::initFromOptions(int argc, char** argv) {
             std::cout << "--volUpButtonBottom=<distance from the bottom of the UP power button to "
                          "the top of the screen in mm>"
                       << std::endl;
+            std::cout << "--saveScreen - save rendered screen to ppm files in working directory"
+                      << std::endl;
             exit(0);
         }
     }
-    createDevice(width, height, dp2px, mm2px, powerBottonTopMm, powerButtonBottomMm,
-                 volUpButtonTopMm, volUpButtonBottomMm);
 }
 
 }  // namespace test
diff --git a/test/teeui_device_config.h b/test/teeui_device_config.h
index 7bcfa5a..ea13b9a 100644
--- a/test/teeui_device_config.h
+++ b/test/teeui_device_config.h
@@ -54,9 +54,11 @@ class TeeuiRenderTest : public ::testing::Test {
     void initFromOptions(int argc, char** argv);
     int runTest(const char* language, bool magnified);
     void TestBody() {}
-    void createDevice(int widthPx, int heightPx, double dp2px, double mm2px,
-                      double powerButtonTopMm, double powerButtonBottomMm, double volUpButtonTopMm,
-                      double volUpButtonBottomMm);
+
+    bool saveScreen() { return saveScreen_; }
+
+  private:
+    bool saveScreen_ = false;
 };
 
 }  // namespace test
diff --git a/test/teeui_draw_label_text_test.cpp b/test/teeui_draw_label_text_test.cpp
index 1f08551..83b8320 100644
--- a/test/teeui_draw_label_text_test.cpp
+++ b/test/teeui_draw_label_text_test.cpp
@@ -39,69 +39,87 @@ static constexpr const char kText100Character1Group[] =
     "WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW"
     "WWWWWWWW";
 
+static constexpr const char kTextMultiLine[] =
+    "Line1\n"
+    "Line2. The next line is blank\n"
+    "\n"
+    "Line4.  This line will wrap onto other lines as it is quite long.\n"
+    "LineN\n"
+    "\n";
+
 class TeeuiDrawLabelTextTest : public ::testing::Test {};
 
 TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_phys_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, &kText12Character8Group[0]);
+    int error = runRenderTest("en", false /* magnified */, false, &kText12Character8Group[0]);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_phys_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, &kText12Character8Group[0]);
+    int error = runRenderTest("en", true /* magnified */, false, &kText12Character8Group[0]);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_phys_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, &kText100Character1Group[0]);
+    int error = runRenderTest("en", false /* magnified */, false, &kText100Character1Group[0]);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_phys_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, &kText100Character1Group[0]);
+    int error = runRenderTest("en", true /* magnified */, false, &kText100Character1Group[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_multi_line_phys_button_layout) {
+    int error = runRenderTest("en", false /* magnified */, false, &kTextMultiLine[0]);
+    ASSERT_EQ(error, 0);
+}
+
+TEST_F(TeeuiDrawLabelTextTest, Test_multi_line_phys_button_layout_magnified) {
+    int error = runRenderTest("en", true /* magnified */, false, &kTextMultiLine[0]);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_phys_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, "");
+    int error = runRenderTest("en", false /* magnified */, false, "");
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_phys_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, "");
+    int error = runRenderTest("en", true /* magnified */, false, "");
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_touch_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, &kText12Character8Group[0],
+    int error = runRenderTest("en", false /* magnified */, false, &kText12Character8Group[0],
                               example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_12_char_8_group_touch_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, &kText12Character8Group[0],
+    int error = runRenderTest("en", true /* magnified */, false, &kText12Character8Group[0],
                               example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_touch_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, &kText100Character1Group[0],
+    int error = runRenderTest("en", false /* magnified */, false, &kText100Character1Group[0],
                               example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_100_char_1_group_touch_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, &kText100Character1Group[0],
+    int error = runRenderTest("en", true /* magnified */, false, &kText100Character1Group[0],
                               example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_touch_button_layout) {
-    int error = runRenderTest("en", false /* magnified */, "", example::kTouchButtonLayout);
+    int error = runRenderTest("en", false /* magnified */, false, "", example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiDrawLabelTextTest, Test_empty_text_touch_button_layout_magnified) {
-    int error = runRenderTest("en", true /* magnified */, "", example::kTouchButtonLayout);
+    int error = runRenderTest("en", true /* magnified */, false, "", example::kTouchButtonLayout);
     ASSERT_EQ(error, 0);
 }
 
diff --git a/test/teeui_locale_test.cpp b/test/teeui_locale_test.cpp
index c81921b..f42af5f 100644
--- a/test/teeui_locale_test.cpp
+++ b/test/teeui_locale_test.cpp
@@ -36,1262 +36,1262 @@ namespace test {
 class TeeuiLocaleTest : public ::testing::Test {};
 
 TEST_F(TeeuiLocaleTest, Test_en) {
-    int error = runRenderTest("en", false /* magnified */);
+    int error = runRenderTest("en", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_en_magnified) {
-    int error = runRenderTest("en", true /* magnified */);
+    int error = runRenderTest("en", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AF) {
-    int error = runRenderTest("af", false /* magnified */);
+    int error = runRenderTest("af", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AF_magnified) {
-    int error = runRenderTest("af", true /* magnified */);
+    int error = runRenderTest("af", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AM) {
-    int error = runRenderTest("am", false /* magnified */);
+    int error = runRenderTest("am", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AM_magnified) {
-    int error = runRenderTest("am", true /* magnified */);
+    int error = runRenderTest("am", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR) {
-    int error = runRenderTest("ar", false /* magnified */);
+    int error = runRenderTest("ar", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_magnified) {
-    int error = runRenderTest("ar", true /* magnified */);
+    int error = runRenderTest("ar", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_EG) {
-    int error = runRenderTest("ar-EG", false /* magnified */);
+    int error = runRenderTest("ar-EG", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_EG_magnified) {
-    int error = runRenderTest("ar-EG", true /* magnified */);
+    int error = runRenderTest("ar-EG", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_JO) {
-    int error = runRenderTest("ar-JO", false /* magnified */);
+    int error = runRenderTest("ar-JO", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_JO_magnified) {
-    int error = runRenderTest("ar-JO", true /* magnified */);
+    int error = runRenderTest("ar-JO", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_MA) {
-    int error = runRenderTest("ar-MA", false /* magnified */);
+    int error = runRenderTest("ar-MA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_MA_magnified) {
-    int error = runRenderTest("ar-MA", true /* magnified */);
+    int error = runRenderTest("ar-MA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_SA) {
-    int error = runRenderTest("ar-SA", false /* magnified */);
+    int error = runRenderTest("ar-SA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_SA_magnified) {
-    int error = runRenderTest("ar-SA", true /* magnified */);
+    int error = runRenderTest("ar-SA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_XB) {
-    int error = runRenderTest("ar-XB", false /* magnified */);
+    int error = runRenderTest("ar-XB", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AR_XB_magnified) {
-    int error = runRenderTest("ar-XB", true /* magnified */);
+    int error = runRenderTest("ar-XB", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AS) {
-    int error = runRenderTest("as", false /* magnified */);
+    int error = runRenderTest("as", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AS_magnified) {
-    int error = runRenderTest("as", true /* magnified */);
+    int error = runRenderTest("as", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AZ) {
-    int error = runRenderTest("az", false /* magnified */);
+    int error = runRenderTest("az", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_AZ_magnified) {
-    int error = runRenderTest("az", true /* magnified */);
+    int error = runRenderTest("az", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BE) {
-    int error = runRenderTest("be", false /* magnified */);
+    int error = runRenderTest("be", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BE_magnified) {
-    int error = runRenderTest("be", true /* magnified */);
+    int error = runRenderTest("be", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BG) {
-    int error = runRenderTest("bg", false /* magnified */);
+    int error = runRenderTest("bg", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BG_magnified) {
-    int error = runRenderTest("bg", true /* magnified */);
+    int error = runRenderTest("bg", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BN) {
-    int error = runRenderTest("bn", false /* magnified */);
+    int error = runRenderTest("bn", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BN_magnified) {
-    int error = runRenderTest("bn", true /* magnified */);
+    int error = runRenderTest("bn", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BS) {
-    int error = runRenderTest("bs", false /* magnified */);
+    int error = runRenderTest("bs", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_BS_magnified) {
-    int error = runRenderTest("bs", true /* magnified */);
+    int error = runRenderTest("bs", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_CA) {
-    int error = runRenderTest("ca", false /* magnified */);
+    int error = runRenderTest("ca", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_CA_magnified) {
-    int error = runRenderTest("ca", true /* magnified */);
+    int error = runRenderTest("ca", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_CS) {
-    int error = runRenderTest("cs", false /* magnified */);
+    int error = runRenderTest("cs", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_CS_magnified) {
-    int error = runRenderTest("cs", true /* magnified */);
+    int error = runRenderTest("cs", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DA) {
-    int error = runRenderTest("da", false /* magnified */);
+    int error = runRenderTest("da", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DA_magnified) {
-    int error = runRenderTest("da", true /* magnified */);
+    int error = runRenderTest("da", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE) {
-    int error = runRenderTest("de", false /* magnified */);
+    int error = runRenderTest("de", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE_magnified) {
-    int error = runRenderTest("de", true /* magnified */);
+    int error = runRenderTest("de", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE_AT) {
-    int error = runRenderTest("de-AT", false /* magnified */);
+    int error = runRenderTest("de-AT", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE_AT_magnified) {
-    int error = runRenderTest("de-AT", true /* magnified */);
+    int error = runRenderTest("de-AT", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE_CH) {
-    int error = runRenderTest("de-CH", false /* magnified */);
+    int error = runRenderTest("de-CH", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_DE_CH_magnified) {
-    int error = runRenderTest("de-CH", true /* magnified */);
+    int error = runRenderTest("de-CH", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EL) {
-    int error = runRenderTest("el", false /* magnified */);
+    int error = runRenderTest("el", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EL_magnified) {
-    int error = runRenderTest("el", true /* magnified */);
+    int error = runRenderTest("el", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_AU) {
-    int error = runRenderTest("en-AU", false /* magnified */);
+    int error = runRenderTest("en-AU", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_AU_magnified) {
-    int error = runRenderTest("en-AU", true /* magnified */);
+    int error = runRenderTest("en-AU", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_CA) {
-    int error = runRenderTest("en-CA", false /* magnified */);
+    int error = runRenderTest("en-CA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_CA_magnified) {
-    int error = runRenderTest("en-CA", true /* magnified */);
+    int error = runRenderTest("en-CA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_GB) {
-    int error = runRenderTest("en-GB", false /* magnified */);
+    int error = runRenderTest("en-GB", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_GB_magnified) {
-    int error = runRenderTest("en-GB", true /* magnified */);
+    int error = runRenderTest("en-GB", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_IE) {
-    int error = runRenderTest("en-IE", false /* magnified */);
+    int error = runRenderTest("en-IE", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_IE_magnified) {
-    int error = runRenderTest("en-IE", true /* magnified */);
+    int error = runRenderTest("en-IE", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_IN) {
-    int error = runRenderTest("en-IN", false /* magnified */);
+    int error = runRenderTest("en-IN", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_IN_magnified) {
-    int error = runRenderTest("en-IN", true /* magnified */);
+    int error = runRenderTest("en-IN", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_NZ) {
-    int error = runRenderTest("en-NZ", false /* magnified */);
+    int error = runRenderTest("en-NZ", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_NZ_magnified) {
-    int error = runRenderTest("en-NZ", true /* magnified */);
+    int error = runRenderTest("en-NZ", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_SG) {
-    int error = runRenderTest("en-SG", false /* magnified */);
+    int error = runRenderTest("en-SG", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_SG_magnified) {
-    int error = runRenderTest("en-SG", true /* magnified */);
+    int error = runRenderTest("en-SG", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_XA) {
-    int error = runRenderTest("en-XA", false /* magnified */);
+    int error = runRenderTest("en-XA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_XA_magnified) {
-    int error = runRenderTest("en-XA", true /* magnified */);
+    int error = runRenderTest("en-XA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_XC) {
-    int error = runRenderTest("en-XC", false /* magnified */);
+    int error = runRenderTest("en-XC", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_XC_magnified) {
-    int error = runRenderTest("en-XC", true /* magnified */);
+    int error = runRenderTest("en-XC", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_ZA) {
-    int error = runRenderTest("en-ZA", false /* magnified */);
+    int error = runRenderTest("en-ZA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EN_ZA_magnified) {
-    int error = runRenderTest("en-ZA", true /* magnified */);
+    int error = runRenderTest("en-ZA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES) {
-    int error = runRenderTest("es", false /* magnified */);
+    int error = runRenderTest("es", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_magnified) {
-    int error = runRenderTest("es", true /* magnified */);
+    int error = runRenderTest("es", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_419) {
-    int error = runRenderTest("es-419", false /* magnified */);
+    int error = runRenderTest("es-419", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_419_magnified) {
-    int error = runRenderTest("es-419", true /* magnified */);
+    int error = runRenderTest("es-419", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_AR) {
-    int error = runRenderTest("es-AR", false /* magnified */);
+    int error = runRenderTest("es-AR", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_AR_magnified) {
-    int error = runRenderTest("es-AR", true /* magnified */);
+    int error = runRenderTest("es-AR", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_BO) {
-    int error = runRenderTest("es-BO", false /* magnified */);
+    int error = runRenderTest("es-BO", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_BO_magnified) {
-    int error = runRenderTest("es-BO", true /* magnified */);
+    int error = runRenderTest("es-BO", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CL) {
-    int error = runRenderTest("es-CL", false /* magnified */);
+    int error = runRenderTest("es-CL", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CL_magnified) {
-    int error = runRenderTest("es-CL", true /* magnified */);
+    int error = runRenderTest("es-CL", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CO) {
-    int error = runRenderTest("es-CO", false /* magnified */);
+    int error = runRenderTest("es-CO", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CO_magnified) {
-    int error = runRenderTest("es-CO", true /* magnified */);
+    int error = runRenderTest("es-CO", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CR) {
-    int error = runRenderTest("es-CR", false /* magnified */);
+    int error = runRenderTest("es-CR", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_CR_magnified) {
-    int error = runRenderTest("es-CR", true /* magnified */);
+    int error = runRenderTest("es-CR", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_DO) {
-    int error = runRenderTest("es-DO", false /* magnified */);
+    int error = runRenderTest("es-DO", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_DO_magnified) {
-    int error = runRenderTest("es-DO", true /* magnified */);
+    int error = runRenderTest("es-DO", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_EC) {
-    int error = runRenderTest("es-EC", false /* magnified */);
+    int error = runRenderTest("es-EC", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_EC_magnified) {
-    int error = runRenderTest("es-EC", true /* magnified */);
+    int error = runRenderTest("es-EC", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_GT) {
-    int error = runRenderTest("es-GT", false /* magnified */);
+    int error = runRenderTest("es-GT", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_GT_magnified) {
-    int error = runRenderTest("es-GT", true /* magnified */);
+    int error = runRenderTest("es-GT", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_HN) {
-    int error = runRenderTest("es-HN", false /* magnified */);
+    int error = runRenderTest("es-HN", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_HN_magnified) {
-    int error = runRenderTest("es-HN", true /* magnified */);
+    int error = runRenderTest("es-HN", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_MX) {
-    int error = runRenderTest("es-MX", false /* magnified */);
+    int error = runRenderTest("es-MX", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_MX_magnified) {
-    int error = runRenderTest("es-MX", true /* magnified */);
+    int error = runRenderTest("es-MX", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_NI) {
-    int error = runRenderTest("es-NI", false /* magnified */);
+    int error = runRenderTest("es-NI", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_NI_magnified) {
-    int error = runRenderTest("es-NI", true /* magnified */);
+    int error = runRenderTest("es-NI", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PA) {
-    int error = runRenderTest("es-PA", false /* magnified */);
+    int error = runRenderTest("es-PA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PA_magnified) {
-    int error = runRenderTest("es-PA", true /* magnified */);
+    int error = runRenderTest("es-PA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PE) {
-    int error = runRenderTest("es-PE", false /* magnified */);
+    int error = runRenderTest("es-PE", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PE_magnified) {
-    int error = runRenderTest("es-PE", true /* magnified */);
+    int error = runRenderTest("es-PE", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PR) {
-    int error = runRenderTest("es-PR", false /* magnified */);
+    int error = runRenderTest("es-PR", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PR_magnified) {
-    int error = runRenderTest("es-PR", true /* magnified */);
+    int error = runRenderTest("es-PR", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PY) {
-    int error = runRenderTest("es-PY", false /* magnified */);
+    int error = runRenderTest("es-PY", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_PY_magnified) {
-    int error = runRenderTest("es-PY", true /* magnified */);
+    int error = runRenderTest("es-PY", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_SV) {
-    int error = runRenderTest("es-SV", false /* magnified */);
+    int error = runRenderTest("es-SV", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_SV_magnified) {
-    int error = runRenderTest("es-SV", true /* magnified */);
+    int error = runRenderTest("es-SV", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_US) {
-    int error = runRenderTest("es-US", false /* magnified */);
+    int error = runRenderTest("es-US", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_US_magnified) {
-    int error = runRenderTest("es-US", true /* magnified */);
+    int error = runRenderTest("es-US", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_UY) {
-    int error = runRenderTest("es-UY", false /* magnified */);
+    int error = runRenderTest("es-UY", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_UY_magnified) {
-    int error = runRenderTest("es-UY", true /* magnified */);
+    int error = runRenderTest("es-UY", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_VE) {
-    int error = runRenderTest("es-VE", false /* magnified */);
+    int error = runRenderTest("es-VE", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ES_VE_magnified) {
-    int error = runRenderTest("es-VE", true /* magnified */);
+    int error = runRenderTest("es-VE", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ET) {
-    int error = runRenderTest("et", false /* magnified */);
+    int error = runRenderTest("et", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ET_magnified) {
-    int error = runRenderTest("et", true /* magnified */);
+    int error = runRenderTest("et", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EU) {
-    int error = runRenderTest("eu", false /* magnified */);
+    int error = runRenderTest("eu", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_EU_magnified) {
-    int error = runRenderTest("eu", true /* magnified */);
+    int error = runRenderTest("eu", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FA) {
-    int error = runRenderTest("fa", false /* magnified */);
+    int error = runRenderTest("fa", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FA_magnified) {
-    int error = runRenderTest("fa", true /* magnified */);
+    int error = runRenderTest("fa", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FI) {
-    int error = runRenderTest("fi", false /* magnified */);
+    int error = runRenderTest("fi", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FI_magnified) {
-    int error = runRenderTest("fi", true /* magnified */);
+    int error = runRenderTest("fi", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FIL) {
-    int error = runRenderTest("fil", false /* magnified */);
+    int error = runRenderTest("fil", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FIL_magnified) {
-    int error = runRenderTest("fil", true /* magnified */);
+    int error = runRenderTest("fil", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR) {
-    int error = runRenderTest("fr", false /* magnified */);
+    int error = runRenderTest("fr", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR_magnified) {
-    int error = runRenderTest("fr", true /* magnified */);
+    int error = runRenderTest("fr", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR_CA) {
-    int error = runRenderTest("fr-CA", false /* magnified */);
+    int error = runRenderTest("fr-CA", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR_CA_magnified) {
-    int error = runRenderTest("fr-CA", true /* magnified */);
+    int error = runRenderTest("fr-CA", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR_CH) {
-    int error = runRenderTest("fr-CH", false /* magnified */);
+    int error = runRenderTest("fr-CH", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_FR_CH_magnified) {
-    int error = runRenderTest("fr-CH", true /* magnified */);
+    int error = runRenderTest("fr-CH", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GL) {
-    int error = runRenderTest("gl", false /* magnified */);
+    int error = runRenderTest("gl", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GL_magnified) {
-    int error = runRenderTest("gl", true /* magnified */);
+    int error = runRenderTest("gl", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GSW) {
-    int error = runRenderTest("gsw", false /* magnified */);
+    int error = runRenderTest("gsw", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GSW_magnified) {
-    int error = runRenderTest("gsw", true /* magnified */);
+    int error = runRenderTest("gsw", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GU) {
-    int error = runRenderTest("gu", false /* magnified */);
+    int error = runRenderTest("gu", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_GU_magnified) {
-    int error = runRenderTest("gu", true /* magnified */);
+    int error = runRenderTest("gu", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HE) {
-    int error = runRenderTest("he", false /* magnified */);
+    int error = runRenderTest("he", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HE_magnified) {
-    int error = runRenderTest("he", true /* magnified */);
+    int error = runRenderTest("he", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HI) {
-    int error = runRenderTest("hi", false /* magnified */);
+    int error = runRenderTest("hi", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HI_magnified) {
-    int error = runRenderTest("hi", true /* magnified */);
+    int error = runRenderTest("hi", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HR) {
-    int error = runRenderTest("hr", false /* magnified */);
+    int error = runRenderTest("hr", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HR_magnified) {
-    int error = runRenderTest("hr", true /* magnified */);
+    int error = runRenderTest("hr", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HU) {
-    int error = runRenderTest("hu", false /* magnified */);
+    int error = runRenderTest("hu", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HU_magnified) {
-    int error = runRenderTest("hu", true /* magnified */);
+    int error = runRenderTest("hu", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HY) {
-    int error = runRenderTest("hy", false /* magnified */);
+    int error = runRenderTest("hy", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_HY_magnified) {
-    int error = runRenderTest("hy", true /* magnified */);
+    int error = runRenderTest("hy", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ID) {
-    int error = runRenderTest("id", false /* magnified */);
+    int error = runRenderTest("id", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ID_magnified) {
-    int error = runRenderTest("id", true /* magnified */);
+    int error = runRenderTest("id", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IN) {
-    int error = runRenderTest("in", false /* magnified */);
+    int error = runRenderTest("in", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IN_magnified) {
-    int error = runRenderTest("in", true /* magnified */);
+    int error = runRenderTest("in", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IS) {
-    int error = runRenderTest("is", false /* magnified */);
+    int error = runRenderTest("is", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IS_magnified) {
-    int error = runRenderTest("is", true /* magnified */);
+    int error = runRenderTest("is", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IT) {
-    int error = runRenderTest("it", false /* magnified */);
+    int error = runRenderTest("it", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IT_magnified) {
-    int error = runRenderTest("it", true /* magnified */);
+    int error = runRenderTest("it", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IW) {
-    int error = runRenderTest("iw", false /* magnified */);
+    int error = runRenderTest("iw", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_IW_magnified) {
-    int error = runRenderTest("iw", true /* magnified */);
+    int error = runRenderTest("iw", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_JA) {
-    int error = runRenderTest("ja", false /* magnified */);
+    int error = runRenderTest("ja", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_JA_magnified) {
-    int error = runRenderTest("ja", true /* magnified */);
+    int error = runRenderTest("ja", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KA) {
-    int error = runRenderTest("ka", false /* magnified */);
+    int error = runRenderTest("ka", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KA_magnified) {
-    int error = runRenderTest("ka", true /* magnified */);
+    int error = runRenderTest("ka", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KK) {
-    int error = runRenderTest("kk", false /* magnified */);
+    int error = runRenderTest("kk", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KK_magnified) {
-    int error = runRenderTest("kk", true /* magnified */);
+    int error = runRenderTest("kk", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KM) {
-    int error = runRenderTest("km", false /* magnified */);
+    int error = runRenderTest("km", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KM_magnified) {
-    int error = runRenderTest("km", true /* magnified */);
+    int error = runRenderTest("km", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KN) {
-    int error = runRenderTest("kn", false /* magnified */);
+    int error = runRenderTest("kn", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KN_magnified) {
-    int error = runRenderTest("kn", true /* magnified */);
+    int error = runRenderTest("kn", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KO) {
-    int error = runRenderTest("ko", false /* magnified */);
+    int error = runRenderTest("ko", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KO_magnified) {
-    int error = runRenderTest("ko", true /* magnified */);
+    int error = runRenderTest("ko", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KY) {
-    int error = runRenderTest("ky", false /* magnified */);
+    int error = runRenderTest("ky", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_KY_magnified) {
-    int error = runRenderTest("ky", true /* magnified */);
+    int error = runRenderTest("ky", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LN) {
-    int error = runRenderTest("ln", false /* magnified */);
+    int error = runRenderTest("ln", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LN_magnified) {
-    int error = runRenderTest("ln", true /* magnified */);
+    int error = runRenderTest("ln", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LO) {
-    int error = runRenderTest("lo", false /* magnified */);
+    int error = runRenderTest("lo", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LO_magnified) {
-    int error = runRenderTest("lo", true /* magnified */);
+    int error = runRenderTest("lo", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LT) {
-    int error = runRenderTest("lt", false /* magnified */);
+    int error = runRenderTest("lt", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LT_magnified) {
-    int error = runRenderTest("lt", true /* magnified */);
+    int error = runRenderTest("lt", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LV) {
-    int error = runRenderTest("lv", false /* magnified */);
+    int error = runRenderTest("lv", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_LV_magnified) {
-    int error = runRenderTest("lv", true /* magnified */);
+    int error = runRenderTest("lv", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MK) {
-    int error = runRenderTest("mk", false /* magnified */);
+    int error = runRenderTest("mk", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MK_magnified) {
-    int error = runRenderTest("mk", true /* magnified */);
+    int error = runRenderTest("mk", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ML) {
-    int error = runRenderTest("ml", false /* magnified */);
+    int error = runRenderTest("ml", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ML_magnified) {
-    int error = runRenderTest("ml", true /* magnified */);
+    int error = runRenderTest("ml", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MN) {
-    int error = runRenderTest("mn", false /* magnified */);
+    int error = runRenderTest("mn", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MN_magnified) {
-    int error = runRenderTest("mn", true /* magnified */);
+    int error = runRenderTest("mn", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MO) {
-    int error = runRenderTest("mo", false /* magnified */);
+    int error = runRenderTest("mo", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MO_magnified) {
-    int error = runRenderTest("mo", true /* magnified */);
+    int error = runRenderTest("mo", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MR) {
-    int error = runRenderTest("mr", false /* magnified */);
+    int error = runRenderTest("mr", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MR_magnified) {
-    int error = runRenderTest("mr", true /* magnified */);
+    int error = runRenderTest("mr", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MS) {
-    int error = runRenderTest("ms", false /* magnified */);
+    int error = runRenderTest("ms", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MS_magnified) {
-    int error = runRenderTest("ms", true /* magnified */);
+    int error = runRenderTest("ms", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MY) {
-    int error = runRenderTest("my", false /* magnified */);
+    int error = runRenderTest("my", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_MY_magnified) {
-    int error = runRenderTest("my", true /* magnified */);
+    int error = runRenderTest("my", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NB) {
-    int error = runRenderTest("nb", false /* magnified */);
+    int error = runRenderTest("nb", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NB_magnified) {
-    int error = runRenderTest("nb", true /* magnified */);
+    int error = runRenderTest("nb", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NE) {
-    int error = runRenderTest("ne", false /* magnified */);
+    int error = runRenderTest("ne", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NE_magnified) {
-    int error = runRenderTest("ne", true /* magnified */);
+    int error = runRenderTest("ne", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NL) {
-    int error = runRenderTest("nl", false /* magnified */);
+    int error = runRenderTest("nl", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NL_magnified) {
-    int error = runRenderTest("nl", true /* magnified */);
+    int error = runRenderTest("nl", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NO) {
-    int error = runRenderTest("no", false /* magnified */);
+    int error = runRenderTest("no", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_NO_magnified) {
-    int error = runRenderTest("no", true /* magnified */);
+    int error = runRenderTest("no", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_OR) {
-    int error = runRenderTest("or", false /* magnified */);
+    int error = runRenderTest("or", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_OR_magnified) {
-    int error = runRenderTest("or", true /* magnified */);
+    int error = runRenderTest("or", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PA) {
-    int error = runRenderTest("pa", false /* magnified */);
+    int error = runRenderTest("pa", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PA_magnified) {
-    int error = runRenderTest("pa", true /* magnified */);
+    int error = runRenderTest("pa", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PL) {
-    int error = runRenderTest("pl", false /* magnified */);
+    int error = runRenderTest("pl", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PL_magnified) {
-    int error = runRenderTest("pl", true /* magnified */);
+    int error = runRenderTest("pl", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT) {
-    int error = runRenderTest("pt", false /* magnified */);
+    int error = runRenderTest("pt", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT_magnified) {
-    int error = runRenderTest("pt", true /* magnified */);
+    int error = runRenderTest("pt", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT_BR) {
-    int error = runRenderTest("pt-BR", false /* magnified */);
+    int error = runRenderTest("pt-BR", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT_BR_magnified) {
-    int error = runRenderTest("pt-BR", true /* magnified */);
+    int error = runRenderTest("pt-BR", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT_PT) {
-    int error = runRenderTest("pt-PT", false /* magnified */);
+    int error = runRenderTest("pt-PT", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_PT_PT_magnified) {
-    int error = runRenderTest("pt-PT", true /* magnified */);
+    int error = runRenderTest("pt-PT", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_RO) {
-    int error = runRenderTest("ro", false /* magnified */);
+    int error = runRenderTest("ro", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_RO_magnified) {
-    int error = runRenderTest("ro", true /* magnified */);
+    int error = runRenderTest("ro", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_RU) {
-    int error = runRenderTest("ru", false /* magnified */);
+    int error = runRenderTest("ru", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_RU_magnified) {
-    int error = runRenderTest("ru", true /* magnified */);
+    int error = runRenderTest("ru", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SI) {
-    int error = runRenderTest("si", false /* magnified */);
+    int error = runRenderTest("si", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SI_magnified) {
-    int error = runRenderTest("si", true /* magnified */);
+    int error = runRenderTest("si", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SK) {
-    int error = runRenderTest("sk", false /* magnified */);
+    int error = runRenderTest("sk", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SK_magnified) {
-    int error = runRenderTest("sk", true /* magnified */);
+    int error = runRenderTest("sk", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SL) {
-    int error = runRenderTest("sl", false /* magnified */);
+    int error = runRenderTest("sl", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SL_magnified) {
-    int error = runRenderTest("sl", true /* magnified */);
+    int error = runRenderTest("sl", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SQ) {
-    int error = runRenderTest("sq", false /* magnified */);
+    int error = runRenderTest("sq", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SQ_magnified) {
-    int error = runRenderTest("sq", true /* magnified */);
+    int error = runRenderTest("sq", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SR) {
-    int error = runRenderTest("sr", false /* magnified */);
+    int error = runRenderTest("sr", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SR_magnified) {
-    int error = runRenderTest("sr", true /* magnified */);
+    int error = runRenderTest("sr", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SR_LATN) {
-    int error = runRenderTest("sr-Latn", false /* magnified */);
+    int error = runRenderTest("sr-Latn", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SR_LATN_magnified) {
-    int error = runRenderTest("sr-Latn", true /* magnified */);
+    int error = runRenderTest("sr-Latn", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SV) {
-    int error = runRenderTest("sv", false /* magnified */);
+    int error = runRenderTest("sv", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SV_magnified) {
-    int error = runRenderTest("sv", true /* magnified */);
+    int error = runRenderTest("sv", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SW) {
-    int error = runRenderTest("sw", false /* magnified */);
+    int error = runRenderTest("sw", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_SW_magnified) {
-    int error = runRenderTest("sw", true /* magnified */);
+    int error = runRenderTest("sw", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TA) {
-    int error = runRenderTest("ta", false /* magnified */);
+    int error = runRenderTest("ta", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TA_magnified) {
-    int error = runRenderTest("ta", true /* magnified */);
+    int error = runRenderTest("ta", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TE) {
-    int error = runRenderTest("te", false /* magnified */);
+    int error = runRenderTest("te", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TE_magnified) {
-    int error = runRenderTest("te", true /* magnified */);
+    int error = runRenderTest("te", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TH) {
-    int error = runRenderTest("th", false /* magnified */);
+    int error = runRenderTest("th", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TH_magnified) {
-    int error = runRenderTest("th", true /* magnified */);
+    int error = runRenderTest("th", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TL) {
-    int error = runRenderTest("tl", false /* magnified */);
+    int error = runRenderTest("tl", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TL_magnified) {
-    int error = runRenderTest("tl", true /* magnified */);
+    int error = runRenderTest("tl", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TR) {
-    int error = runRenderTest("tr", false /* magnified */);
+    int error = runRenderTest("tr", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_TR_magnified) {
-    int error = runRenderTest("tr", true /* magnified */);
+    int error = runRenderTest("tr", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UK) {
-    int error = runRenderTest("uk", false /* magnified */);
+    int error = runRenderTest("uk", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UK_magnified) {
-    int error = runRenderTest("uk", true /* magnified */);
+    int error = runRenderTest("uk", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UR) {
-    int error = runRenderTest("ur", false /* magnified */);
+    int error = runRenderTest("ur", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UR_magnified) {
-    int error = runRenderTest("ur", true /* magnified */);
+    int error = runRenderTest("ur", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UZ) {
-    int error = runRenderTest("uz", false /* magnified */);
+    int error = runRenderTest("uz", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_UZ_magnified) {
-    int error = runRenderTest("uz", true /* magnified */);
+    int error = runRenderTest("uz", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_VI) {
-    int error = runRenderTest("vi", false /* magnified */);
+    int error = runRenderTest("vi", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_VI_magnified) {
-    int error = runRenderTest("vi", true /* magnified */);
+    int error = runRenderTest("vi", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH) {
-    int error = runRenderTest("zh", false /* magnified */);
+    int error = runRenderTest("zh", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_magnified) {
-    int error = runRenderTest("zh", true /* magnified */);
+    int error = runRenderTest("zh", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_CN) {
-    int error = runRenderTest("zh-CN", false /* magnified */);
+    int error = runRenderTest("zh-CN", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_CN_magnified) {
-    int error = runRenderTest("zh-CN", true /* magnified */);
+    int error = runRenderTest("zh-CN", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_HK) {
-    int error = runRenderTest("zh-HK", false /* magnified */);
+    int error = runRenderTest("zh-HK", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_HK_magnified) {
-    int error = runRenderTest("zh-HK", true /* magnified */);
+    int error = runRenderTest("zh-HK", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_TW) {
-    int error = runRenderTest("zh-TW", false /* magnified */);
+    int error = runRenderTest("zh-TW", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZH_TW_magnified) {
-    int error = runRenderTest("zh-TW", true /* magnified */);
+    int error = runRenderTest("zh-TW", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZU) {
-    int error = runRenderTest("zu", false /* magnified */);
+    int error = runRenderTest("zu", false /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
 TEST_F(TeeuiLocaleTest, Test_ZU_magnified) {
-    int error = runRenderTest("zu", true /* magnified */);
+    int error = runRenderTest("zu", true /* magnified */, false /* inverted */);
     ASSERT_EQ(error, 0);
 }
 
diff --git a/tools/framebufferizer/Android.bp b/tools/framebufferizer/Android.bp
index b718884..489f4ce 100644
--- a/tools/framebufferizer/Android.bp
+++ b/tools/framebufferizer/Android.bp
@@ -11,7 +11,7 @@ java_binary_host {
     manifest: "manifest-teeui-framebufferizer.mf",
     static_libs: [
         "json-prebuilt",
-        "gson-prebuilt-jar",
+        "gson",
     ],
     required: [
         "libteeui_jni",