Fix writing hex values in ImmutableStringBuilder

The old code was accidentally using letters offset by 10 when writing
out hex values >= 10. Now the letters a to f are used as they should.

This is one issue that changed shader output when ImmutableString was
introduced, so it is a potential cause for a regression detailed in
bug 824062, though this has not been verified.

BUG=chromium:824062
TEST=angle_unittests

Change-Id: Idb871dffba32a3ab20df0fe17b4b1a98ec00b7fa
Reviewed-on: https://chromium-review.googlesource.com/999480
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>

Author: Olli Etuaho

src/compiler/translator/ImmutableStringBuilder.h

@@ -47,7 +47,7 @@ class ImmutableStringBuilder
         while (index >= 0)
         {
             char digit     = static_cast<char>((number >> (index * 4)) & 0xfu);
-            char digitChar = digit < 10 ? digit + '0' : digit + 'a';
+            char digitChar = (digit < 10) ? (digit + '0') : (digit + ('a' - 10));
             mData[mPos++]  = digitChar;
             --index;
         }

src/tests/angle_unittests.gypi

@@ -72,6 +72,7 @@
             '<(angle_path)/src/tests/compiler_tests/GLSLCompatibilityOutput_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/GlFragDataNotModified_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/GeometryShader_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/ImmutableString_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ImmutableString_test_autogen.cpp',
             '<(angle_path)/src/tests/compiler_tests/InitOutputVariables_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/IntermNode_test.cpp',

src/tests/compiler_tests/ImmutableString_test.cpp

@@ -0,0 +1,74 @@
+// Copyright 2018 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ImmutableString_test.cpp:
+//   Tests for ImmutableString and ImmutableStringBuilder.
+
+#include "compiler/translator/ImmutableString.h"
+#include "compiler/translator/ImmutableStringBuilder.h"
+#include "compiler/translator/PoolAlloc.h"
+#include "gtest/gtest.h"
+
+using namespace sh;
+
+class ImmutableStringBuilderTest : public testing::Test
+{
+  public:
+    ImmutableStringBuilderTest() {}
+
+  protected:
+    void SetUp() override
+    {
+        allocator.push();
+        SetGlobalPoolAllocator(&allocator);
+    }
+
+    void TearDown() override
+    {
+        SetGlobalPoolAllocator(nullptr);
+        allocator.pop();
+    }
+
+    TPoolAllocator allocator;
+};
+
+// Test writing a 32-bit signed int as hexadecimal using ImmutableStringBuilder.
+TEST_F(ImmutableStringBuilderTest, AppendHexInt32)
+{
+    int32_t i = -1;
+    ImmutableStringBuilder strBuilder(2 * sizeof(int32_t));
+    strBuilder.appendHex(i);
+    ImmutableString str = strBuilder;
+    EXPECT_EQ(std::string("ffffffff"), str.data());
+}
+
+// Test writing a 32-bit unsigned int as hexadecimal using ImmutableStringBuilder.
+TEST_F(ImmutableStringBuilderTest, AppendHexUint32)
+{
+    uint32_t i = 0x1234beefu;
+    ImmutableStringBuilder strBuilder(2 * sizeof(uint32_t));
+    strBuilder.appendHex(i);
+    ImmutableString str = strBuilder;
+    EXPECT_EQ(std::string("1234beef"), str.data());
+}
+
+// Test writing a 64-bit signed int as hexadecimal using ImmutableStringBuilder.
+TEST_F(ImmutableStringBuilderTest, AppendHexInt64)
+{
+    int64_t i = -1;
+    ImmutableStringBuilder strBuilder(2 * sizeof(int64_t));
+    strBuilder.appendHex(i);
+    ImmutableString str = strBuilder;
+    EXPECT_EQ(std::string("ffffffffffffffff"), str.data());
+}
+
+// Test writing a 64-bit unsigned int as hexadecimal using ImmutableStringBuilder.
+TEST_F(ImmutableStringBuilderTest, AppendHexUint64)
+{
+    uint64_t i = 0xfeedcafe9876beefull;
+    ImmutableStringBuilder strBuilder(2 * sizeof(uint64_t));
+    strBuilder.appendHex(i);
+    ImmutableString str = strBuilder;
+    EXPECT_EQ(std::string("feedcafe9876beef"), str.data());
+}