Add test for FixedStreamArrayIterator::operator->

[amccarth]

Summary

The operator-> implementation comes from iterator_facade_base, so it should just work given that the iterator has a tested operator*. But r302257 showed that required careful handling of for the const qualifier. This patch ensures the fix in r302257 doesn't regress.

[dblaikie]

Seems good, though I don't know all that much about the API :)

llvm/trunk/unittests/Support/BinaryStreamTest.cpp

 #include "llvm/Support/BinaryItemStream.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "gtest/gtest.h"
 
 #include <unordered_map>
+#include <utility>
 
 using namespace llvm;
 using namespace llvm::support;
 
 #define EXPECT_NO_ERROR(Err)                                                   \
   {                                                                            \
     auto E = Err;                                                              \
     EXPECT_FALSE(static_cast<bool>(E));                                        \
private:
   }
 
   uint32_t endIndex(uint32_t Offset, uint32_t Size) const {
     return (startIndex(Offset) + Size - 1) % Data.size();
   }
 
   // Buffer is organized like this:
   // -------------------------------------------------
-  // | N/2 | N/2+1 | ... | N-1 | 0 | 1 | ... | N-2-1 |
+  // | N/2 | N/2+1 | ... | N-1 | 0 | 1 | ... | N/2-1 |
   // -------------------------------------------------
   // So reads from the beginning actually come from the middle.
   MutableArrayRef<uint8_t> Data;
   uint32_t PartitionIndex = 0;
   endianness Endian;
   BumpPtrAllocator Allocator;
 };
 
for (auto &Stream : Streams) {
     ASSERT_EQ(Ints[0], *Iter++);
     ASSERT_EQ(Ints[1], *Iter++);
     ASSERT_EQ(Ints[2], *Iter++);
     ASSERT_EQ(Ints[3], *Iter++);
     ASSERT_EQ(Array.end(), Iter);
   }
 }
 
+// Ensure FixedStreamArrayIterator::operator-> works.
+// Added for coverage of r302257.
+TEST_F(BinaryStreamTest, FixedStreamArrayIteratorArrow) {
+  std::vector<std::pair<uint32_t, uint32_t>> Pairs = {{867, 5309}, {555, 1212}};
+  ArrayRef<uint8_t> PairBytes(reinterpret_cast<uint8_t *>(Pairs.data()),
+    Pairs.size() * sizeof(Pairs[0]));
+
+  initializeInput(PairBytes, alignof(uint32_t));
+
+  for (auto &Stream : Streams) {
+    ASSERT_EQ(InputData.size(), Stream.Input->getLength());
+
+    const FixedStreamArray<std::pair<uint32_t, uint32_t>> Array(*Stream.Input);
+    auto Iter = Array.begin();
+    ASSERT_EQ(Pairs[0].first, Iter->first);
+    ASSERT_EQ(Pairs[0].second, Iter->second);
+    ++Iter;
+    ASSERT_EQ(Pairs[1].first, Iter->first);
+    ASSERT_EQ(Pairs[1].second, Iter->second);
+    ++Iter;
+    ASSERT_EQ(Array.end(), Iter);
+  }
+}
+
 // Test that VarStreamArray works correctly.
 TEST_F(BinaryStreamTest, VarStreamArray) {
   StringLiteral Strings("1. Test2. Longer Test3. Really Long Test4. Super "
                         "Extra Longest Test Of All");
   ArrayRef<uint8_t> StringBytes(
       reinterpret_cast<const uint8_t *>(Strings.data()), Strings.size());
   initializeInput(StringBytes, 1);
 
TEST_F(BinaryStreamTest, BinaryItemStream) {
 
   struct Foo {
     int X;
     double Y;
   };
   std::vector<Foo> Foos = {{1, 1.0}, {2, 2.0}, {3, 3.0}};
   BumpPtrAllocator Allocator;
   for (const auto &F : Foos) {
-    uint8_t *Ptr = static_cast<uint8_t *>(Allocator.Allocate(sizeof(Foo), 
+    uint8_t *Ptr = static_cast<uint8_t *>(Allocator.Allocate(sizeof(Foo),
                                                              alignof(Foo)));
     MutableArrayRef<uint8_t> Buffer(Ptr, sizeof(Foo));
     MutableBinaryByteStream Stream(Buffer, llvm::support::big);
     BinaryStreamWriter Writer(Stream);
     ASSERT_NO_ERROR(Writer.writeObject(F));
     Objects.push_back(BinaryItemStreamObject(Buffer));
   }