Add stream class raw_abbrev_ostream

[sepavloff]

Summary

This class allows to mark regions in input data that may be replaced
by SHA1 hash or truncated if the number of symbols in that region exceeds
specified limit.

The new class supports two modes, transparent and abbreviating. In the
transparent mode the class behaves like usual stream, sending all input to
internal buffer. In the abbreviating mode it counts number of symbols in
input data. If the number is less than the specified limit, the input data
go to the buffer as in transparent mode. If the number exceeds the limit,
the input is replaced either by its hash or by truncated value.

The class is intended to be used for building object names or messages,
which may be arbitrary long. For instance, type names in IR may contain
template parameter names for template specializations. In some real life
cases these names can become really huge. By replacing long template
parameter sequence with a hash value, the type name remains compact and
still can identify the type across translation units.

[rnk]

I commented on the clang review that I'm not sure this is really a good fit for support.

[sepavloff]

Using llvm type names is considered a wrong direction.

include/llvm/Support/raw_abbrev_ostream.h

+//==- raw_abbrev_ostream.h - Stream that can abbreviate content --*- C++ -*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the raw_abbrev_ostream class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_RAW_ABBREV_OSTREAM_H
+#define LLVM_SUPPORT_RAW_ABBREV_OSTREAM_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/SHA1.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+/// A raw_ostream that can replace some part of input with shorter text.
+///
+/// This stream class can operate in two modes: transparent and abbreviating. In
+/// transparent mode it behaves like usual stream and stores input in internal
+/// buffer. In abbreviating mode it counts number of symbols it got in this
+/// mode. If this number is less than specified limit, the input is put into the
+/// buffer as is. If the number exceeds this limit, the input is replaced by
+/// some text. Depending on the stream options, this text may be a hash
+/// calculated for the input data or this data may be truncated at the specified
+/// length.
+///
+/// Example:
+/// \code
+///    raw_abbrev_ostream S;
+///
+///    // Replace long text with its hash.
+///    S << "Text: ";
+///    S.setBeginMarker("(").setEndMarker(")").setLimit(6);
+///    S.startAbbrev();
+///    S << "Text that may be long";
+///    StringRef Result = S.str();
+///    assert(Result == "Text: (E06D5F32D15DEAB57D9FE2002C3F39D9B1CF306C)");
+///
+///    // Short text is passed as is.
+///    S.reset();
+///    S.setBeginMarker("(").setEndMarker(")").setLimit(100);
+///    S << "Text: ";
+///    S.startAbbrev();
+///    S << "Text that may be long";
+///    Result = S.str();
+///    assert(Result == "Text: Text that may be long");
+///
+///    // Truncate long text.
+///    S.reset();
+///    S.setEndMarker("...").setLimit(6);
+///    S.setTrunc().setHash(false);
+///    S << "Text: ";
+///    S.startAbbrev();
+///    S << "Text that may be long";
+///    Result = S.str();
+///    assert(Result == "Text: Text t...");
+/// \endcode
+///
+class raw_abbrev_ostream : public raw_ostream {
+
+  /// Maximal length of input that can be passed without being replaced
+  /// by abbreviated text.
+  size_t Limit = 0;
+
+  /// This text is put before the hash value.
+  StringRef BeginMarker;
+
+  /// This text is put after the abbreviated value.
+  StringRef EndMarker;
+
+  /// If true, input is replaced by its hash if it exceeds Limit.
+  bool AbbreviateByHash = true;
+
+  /// If true, initial part of of input is passed to output.
+  bool Truncate = false;
+
+  /// Buffer that keeps the stream content.
+  SmallString<64> OS;
+
+  /// Hash calculator.
+  SHA1 Hasher;
+
+  /// Start of current fragment, if abbreviating mode is enabled, or
+  /// StringRef::npos in transparent mode.
+  size_t Start = StringRef::npos;
+
+  /// Length of the current fragment, if abbreviating mode is enabled.
+  size_t Length = 0;
+
+  /// See raw_ostream::write_impl.
+  void write_impl(const char *Ptr, size_t Size) override;
+
+  /// Append calculated hash value at the end of stream buffer.
+  void appendHash();
+
+  /// Put abbreviated value into buffer.
+  void appendAbbrevValue();
+
+public:
+  raw_abbrev_ostream() : raw_ostream(true) { }
+
+  LLVM_NODISCARD StringRef getBeginMarker() const { return BeginMarker; }
+  LLVM_NODISCARD StringRef getEndMarker() const { return EndMarker; }
+  LLVM_NODISCARD size_t getLimit() const { return Limit; }
+
+  /// Return true, if input will be abbreviated by hash.
+  LLVM_NODISCARD bool usesHash() const { return AbbreviateByHash; }
+
+  /// Return true, if input will be abbreviated by truncation.
+  LLVM_NODISCARD bool usesTrunc() const { return Truncate; }
+
+  /// Return true if the stream is in abbreviating mode.
+  LLVM_NODISCARD bool inAbbrevMode() const { return Start < StringRef::npos; }
+
+  /// Return true if current fragment is long enough and will be abbreviated.
+  LLVM_NODISCARD bool isLong() const { return Length > Limit; }
+
+  raw_abbrev_ostream &setBeginMarker(StringRef B = StringRef()) {
+    BeginMarker = B;
+    return *this;
+  }
+
+  raw_abbrev_ostream &setEndMarker(StringRef E = StringRef()) {
+    EndMarker = E;
+    return *this;
+  }
+
+  raw_abbrev_ostream &setHash(bool X = true) {
+    AbbreviateByHash = X;
+    return *this;
+  }
+
+  raw_abbrev_ostream &setTrunc(bool X = true) {
+    Truncate = X;
+    return *this;
+  }
+
+  /// Subsequent input may be abbreviated if it is longer that the specified
+  /// limit.
+  raw_abbrev_ostream &setLimit(size_t X) {
+    Limit = X;
+    return *this;
+  }
+
+  /// Subsequent input may be abbreviated if it is longer that the specified
+  /// limit.
+  raw_abbrev_ostream &startAbbrev();
+
+  /// Subsequent input will be put into buffer as is.
+  raw_abbrev_ostream &stopAbbrev();
+
+  /// Put the stream into initial state.
+  void reset();
+
+  /// Get buffer containing the stream content.
+  LLVM_NODISCARD StringRef str();
+
+  uint64_t current_pos() const override;
+};
+
+} // end llvm namespace
+
+#endif
 No newline at end of file

lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   Timer.cpp
   ToolOutputFile.cpp
   TrigramIndex.cpp
   Triple.cpp
   Twine.cpp
   Unicode.cpp
   YAMLParser.cpp
   YAMLTraits.cpp
+  raw_abbrev_ostream.cpp
   raw_os_ostream.cpp
   raw_ostream.cpp
   regcomp.c
   regerror.c
   regexec.c
   regfree.c
   regstrlcpy.c
   xxhash.cpp

lib/Support/raw_abbrev_ostream.cpp

+//===--- raw_abbrev_ostream.cpp - Implement the raw_abbvev_ostream class --===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This implements raw_abbrev_ostream.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/raw_abbrev_ostream.h"
+using namespace llvm;
+
+const size_t HashTextSize = 40;   // SHA1 hash is 160 bits.
+
+void raw_abbrev_ostream::write_impl(const char *Ptr, size_t Size) {
+  if (inAbbrevMode()) {
+    if (AbbreviateByHash)
+      Hasher.update(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
+    size_t NewLength = Length + Size;
+    if (NewLength <= Limit)
+      OS.append(StringRef(Ptr, Size));
+    else {
+      if (Truncate) {
+        if (Length < Limit)
+          OS.append(StringRef(Ptr, Limit - Length));
+      } else
+        OS.set_size(Start);
+    }
+    Length = NewLength;
+  } else {
+    OS.append(StringRef(Ptr, Size));
+  }
+}
+
+void raw_abbrev_ostream::appendHash() {
+  static const char *const Digits = "0123456789ABCDEF";
+  StringRef Bin = Hasher.result();
+  for (size_t I = 0; I < Bin.size(); ++I) {
+    const unsigned char C = Bin[I];
+    OS.push_back(Digits[C >> 4]);
+    OS.push_back(Digits[C & 15]);
+  }
+}
+
+void raw_abbrev_ostream::appendAbbrevValue() {
+  if (AbbreviateByHash) {
+    OS.append(BeginMarker);
+    appendHash();
+  }
+  OS.append(EndMarker);
+}
+
+
+void raw_abbrev_ostream::reset() {
+  Limit = 0;
+  BeginMarker = EndMarker = StringRef();
+  AbbreviateByHash = true;
+  Truncate = false;
+  OS.clear();
+  Hasher.init();
+  Start = StringRef::npos;
+  Length = 0;
+}
+
+raw_abbrev_ostream &raw_abbrev_ostream::startAbbrev() {
+  // If current mode is abbreviating, close it and start new fragment.
+  stopAbbrev();
+  Start = OS.size();
+  Length = 0;
+  Hasher.init();
+  return *this;
+}
+
+raw_abbrev_ostream &raw_abbrev_ostream::stopAbbrev() {
+  if (inAbbrevMode() && isLong())
+    appendAbbrevValue();
+  Start = StringRef::npos;
+  return *this;
+}
+
+StringRef raw_abbrev_ostream::str() {
+  if (inAbbrevMode() && isLong()) {
+    // Abbreviating mode is active. Put current abbreviated value into buffer,
+    // get StringRef for it and then revert buffer state.
+    size_t PrevSize = OS.size();
+    appendAbbrevValue();
+    StringRef Result = OS.str();
+    OS.set_size(PrevSize);
+    return Result;
+  }
+  return OS.str();
+}
+
+uint64_t raw_abbrev_ostream::current_pos() const {
+  if (inAbbrevMode() && isLong()) {
+    // Report position as if abbreviated value is put into buffer. It would
+    // be consistent with size of string returned by str().
+    size_t Result = Start + EndMarker.size();
+    if (AbbreviateByHash)
+      Result += HashTextSize + BeginMarker.size();
+    if (Truncate)
+      Result += Limit;
+    return Result;
+  }
+  return OS.size();
+}

unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   TimerTest.cpp
   TypeNameTest.cpp
   TrailingObjectsTest.cpp
   TrigramIndexTest.cpp
   UnicodeTest.cpp
   YAMLIOTest.cpp
   YAMLParserTest.cpp
   formatted_raw_ostream_test.cpp
+  raw_abbrev_ostream_test.cpp
   raw_ostream_test.cpp
   raw_pwrite_stream_test.cpp
   raw_sha1_ostream_test.cpp
   xxhashTest.cpp
   )
 
 # Disable all warning for AlignOfTest.cpp,
 # as it does things intentionally, and there is no reliable way of
 # disabling all warnings for all the compilers by using pragmas.
 set_source_files_properties(AlignOfTest.cpp PROPERTIES COMPILE_FLAGS -w)
 
 # ManagedStatic.cpp uses <pthread>.
 target_link_libraries(SupportTests LLVMTestingSupport ${LLVM_PTHREAD_LIB})
 
 add_subdirectory(DynamicLibrary)

unittests/Support/raw_abbrev_ostream_test.cpp

+//===- llvm/unittest/Support/raw_abbrev_ostream_test.cpp ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/raw_abbrev_ostream.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+const size_t HashTextSize = 40;   // SHA1 hash is 160 bits.
+
+
+// If raw_abbrev_ostream is in transparent mode, it operates as usual stream.
+TEST(raw_abbrev_ostreamTest, Transparent) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  ASSERT_TRUE(AbbrevStream.usesHash());
+  ASSERT_FALSE(AbbrevStream.usesTrunc());
+  ASSERT_EQ(AbbrevStream.getLimit(), 0);
+  ASSERT_TRUE(AbbrevStream.getBeginMarker().empty());
+  ASSERT_TRUE(AbbrevStream.getEndMarker().empty());
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_TRUE(AbbrevStream.str().empty());
+  ASSERT_EQ(AbbrevStream.current_pos(), 0);
+
+  AbbrevStream << "Hello World!";
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_EQ("Hello World!", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello World!"));
+
+  AbbrevStream.stopAbbrev();
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_EQ("Hello World!", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello World!"));
+
+  AbbrevStream.reset();
+  ASSERT_TRUE(AbbrevStream.usesHash());
+  ASSERT_FALSE(AbbrevStream.usesTrunc());
+  ASSERT_EQ(AbbrevStream.getLimit(), 0);
+  ASSERT_TRUE(AbbrevStream.getBeginMarker().empty());
+  ASSERT_TRUE(AbbrevStream.getEndMarker().empty());
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_TRUE(AbbrevStream.str().empty());
+  ASSERT_EQ(AbbrevStream.current_pos(), 0);
+
+  AbbrevStream << "Another Text";
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_EQ("Another Text", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Another Text"));
+
+  AbbrevStream.reset();
+  AbbrevStream << "Hello ";
+  AbbrevStream << "World!";
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_EQ("Hello World!", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello World!"));
+}
+
+
+// The mode when stream coverts entire text to SHA1 hash.
+TEST(raw_abbrev_ostreamTest, Hash) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  AbbrevStream.startAbbrev();
+  ASSERT_TRUE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_TRUE(AbbrevStream.str().empty());
+  ASSERT_EQ(AbbrevStream.current_pos(), 0);
+
+  AbbrevStream << "Hello World!";
+  ASSERT_TRUE(AbbrevStream.inAbbrevMode());
+  ASSERT_TRUE(AbbrevStream.isLong());
+  ASSERT_EQ(AbbrevStream.str(), "2EF7BDE608CE5404E97D5F042F95F89F1C232871");
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+
+  AbbrevStream << "";
+  ASSERT_EQ(AbbrevStream.str(), "2EF7BDE608CE5404E97D5F042F95F89F1C232871");
+  AbbrevStream.stopAbbrev();
+  ASSERT_EQ(AbbrevStream.str(), "2EF7BDE608CE5404E97D5F042F95F89F1C232871");
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+
+  AbbrevStream.reset();
+  ASSERT_TRUE(AbbrevStream.usesHash());
+  ASSERT_FALSE(AbbrevStream.usesTrunc());
+  ASSERT_EQ(AbbrevStream.getLimit(), 0);
+  ASSERT_TRUE(AbbrevStream.getBeginMarker().empty());
+  ASSERT_TRUE(AbbrevStream.getEndMarker().empty());
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_TRUE(AbbrevStream.str().empty());
+  ASSERT_EQ(AbbrevStream.current_pos(), 0);
+
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "Hello";
+  ASSERT_TRUE(AbbrevStream.inAbbrevMode());
+  ASSERT_TRUE(AbbrevStream.isLong());
+  ASSERT_EQ(AbbrevStream.str(), "F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0");
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+  AbbrevStream << " World!";
+  ASSERT_TRUE(AbbrevStream.inAbbrevMode());
+  ASSERT_TRUE(AbbrevStream.isLong());
+  ASSERT_EQ(AbbrevStream.str(), "2EF7BDE608CE5404E97D5F042F95F89F1C232871");
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+}
+
+// The mode when stream truncates text.
+TEST(raw_abbrev_ostreamTest, Truncate) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  AbbrevStream.setTrunc().setHash(false).setEndMarker("...");
+  ASSERT_FALSE(AbbrevStream.usesHash());
+  ASSERT_TRUE(AbbrevStream.usesTrunc());
+  ASSERT_EQ(AbbrevStream.getLimit(), 0);
+  ASSERT_TRUE(AbbrevStream.getBeginMarker().empty());
+  ASSERT_EQ(AbbrevStream.getEndMarker(), "...");
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_FALSE(AbbrevStream.isLong());
+  ASSERT_TRUE(AbbrevStream.str().empty());
+  ASSERT_EQ(AbbrevStream.current_pos(), 0);
+
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "Hello";
+  ASSERT_TRUE(AbbrevStream.inAbbrevMode());
+  ASSERT_TRUE(AbbrevStream.isLong());
+  ASSERT_EQ(AbbrevStream.str(), "...");
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("..."));
+
+  AbbrevStream.stopAbbrev();
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_EQ(AbbrevStream.str(), "...");
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("..."));
+
+  AbbrevStream.reset();
+  AbbrevStream.setTrunc().setHash(false).setEndMarker("...").setLimit(7);
+  AbbrevStream.startAbbrev() << "Hello World!";
+  ASSERT_EQ(AbbrevStream.str(), "Hello W...");
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello W..."));
+
+  AbbrevStream.stopAbbrev();
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_EQ(AbbrevStream.str(), "Hello W...");
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello W..."));
+
+  AbbrevStream.reset();
+  AbbrevStream.setTrunc().setEndMarker(".").setBeginMarker("...").setLimit(7);
+  AbbrevStream.startAbbrev() << "Hello World!";
+  const StringRef T1 = "Hello W...2EF7BDE608CE5404E97D5F042F95F89F1C232871.";
+  ASSERT_EQ(AbbrevStream.str(), T1);
+  ASSERT_EQ(AbbrevStream.current_pos(), T1.size());
+
+  AbbrevStream.stopAbbrev();
+  ASSERT_FALSE(AbbrevStream.inAbbrevMode());
+  ASSERT_EQ(AbbrevStream.str(), T1);
+  ASSERT_EQ(AbbrevStream.current_pos(), T1.size());
+}
+
+
+TEST(raw_abbrev_ostreamTest, ModeSwitch) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+
+  // Switch from transparent mode and immediately back should not have effect.
+  AbbrevStream << "Hello ";
+  AbbrevStream.startAbbrev();
+  AbbrevStream.stopAbbrev();
+  AbbrevStream << "World!";
+  ASSERT_EQ("Hello World!", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello World!"));
+
+  AbbrevStream.reset();
+  AbbrevStream << "Hello ";
+  ASSERT_EQ("Hello ", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello "));
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "World!";
+  ASSERT_EQ("Hello 9D781958AD163647E5C5E724D534D5D9DB7B800D",
+            AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello ") + HashTextSize);
+  AbbrevStream.stopAbbrev();
+  AbbrevStream << " World";
+  ASSERT_EQ("Hello 9D781958AD163647E5C5E724D534D5D9DB7B800D World",
+            AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(),
+            strlen("Hello ") + HashTextSize + strlen("World "));
+}
+
+
+TEST(raw_abbrev_ostreamTest, Length) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  AbbrevStream.setLimit(5).startAbbrev();
+  AbbrevStream << "Hello";
+  ASSERT_EQ("Hello", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello"));
+
+  AbbrevStream << " ";
+  ASSERT_EQ("9646BA13A4E8EABECA4F5259BFD7DA41D368A1A6", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+
+  AbbrevStream << "World!";
+  ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+
+  AbbrevStream.stopAbbrev();
+  ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), HashTextSize);
+
+  AbbrevStream.reset();
+  AbbrevStream.setLimit(20).startAbbrev() << "Hello World!";
+  ASSERT_EQ("Hello World!", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello World!"));
+}
+
+TEST(raw_abbrev_ostreamTest, Markers) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  AbbrevStream.setBeginMarker(".").setLimit(5);
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "Hello";
+  ASSERT_EQ("Hello", AbbrevStream.str());
+  ASSERT_EQ(AbbrevStream.current_pos(), strlen("Hello"));
+
+  AbbrevStream << " ";
+  ASSERT_EQ(".9646BA13A4E8EABECA4F5259BFD7DA41D368A1A6",
+            AbbrevStream.str());
+  // Starts new fragment.
+  AbbrevStream.startAbbrev();
+  AbbrevStream.setEndMarker(")");
+  AbbrevStream << "World!";
+  ASSERT_EQ(".9646BA13A4E8EABECA4F5259BFD7DA41D368A1A6"
+            ".9D781958AD163647E5C5E724D534D5D9DB7B800D)", AbbrevStream.str());
+
+  AbbrevStream.reset();
+  AbbrevStream.setBeginMarker("<").setEndMarker("...");
+  AbbrevStream.setLimit(5).setTrunc().setHash(false);
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "Hello World!";
+  ASSERT_EQ("Hello...", AbbrevStream.str());
+}
+
+TEST(raw_abbrev_ostreamTest, Combination) {
+  llvm::raw_abbrev_ostream AbbrevStream;
+  AbbrevStream.setBeginMarker(".").setLimit(5);
+  AbbrevStream << "struct.Foo";
+  AbbrevStream.startAbbrev();
+  AbbrevStream << '<';
+  AbbrevStream << "int";
+  AbbrevStream << '>';
+  ASSERT_EQ("struct.Foo<int>", AbbrevStream.str());
+
+  AbbrevStream.reset();
+  AbbrevStream.setBeginMarker(".");
+  AbbrevStream << "struct.Foo";
+  AbbrevStream.setLimit(5).startAbbrev();
+  AbbrevStream << '<';
+  AbbrevStream << "int, double";
+  AbbrevStream << '>';
+  ASSERT_EQ("struct.Foo.94979910F7FF30A19B3A475EE1F495EE06E2949E",
+            AbbrevStream.str());
+
+  AbbrevStream.stopAbbrev();
+  AbbrevStream << " foo(";
+  AbbrevStream.setLimit(0).startAbbrev();
+  AbbrevStream.setBeginMarker(".");
+  AbbrevStream << "int";
+  AbbrevStream.stopAbbrev();
+  AbbrevStream << ",";
+  AbbrevStream.startAbbrev();
+  AbbrevStream << "double";
+  AbbrevStream.stopAbbrev();
+  AbbrevStream << ")";
+
+  ASSERT_EQ("struct.Foo.94979910F7FF30A19B3A475EE1F495EE06E2949E"
+            " foo(.46F8AB7C0CFF9DF7CD124852E26022A6BF89E315,"
+            ".BDB36BB22DEB169275B3094BA9005A29EEDDD195)",
+            AbbrevStream.str());
+}
+
+
+// Example from th description of class raw_abbrev_ostream.
+TEST(raw_abbrev_ostreamTest, Example) {
+  using llvm::raw_abbrev_ostream;
+
+  // Replace long text with its hash.
+  raw_abbrev_ostream S;
+  S << "Text: ";
+  S.setBeginMarker("(").setEndMarker(")").setLimit(6);
+  S.startAbbrev();
+  S << "Text that may be long";
+  StringRef Result = S.str();
+  assert(Result == "Text: (E06D5F32D15DEAB57D9FE2002C3F39D9B1CF306C)");
+
+  // Short text is passed as is.
+  S.reset();
+  S.setBeginMarker("(").setEndMarker(")").setLimit(100);
+  S << "Text: ";
+  S.startAbbrev();
+  S << "Text that may be long";
+  Result = S.str();
+  assert(Result == "Text: Text that may be long");
+
+  // Truncate long text.
+  S.reset();
+  S.setEndMarker("...").setLimit(6);
+  S.setTrunc().setHash(false);
+  S << "Text: ";
+  S.startAbbrev();
+  S << "Text that may be long";
+  Result = S.str();
+  assert(Result == "Text: Text t...");
+}