* Carry a message's default instance which is used by {@code hashCode()}, {@code equals()}, and
   * {@code toString()}.
   */
  private final MessageLite defaultInstance;

  public LazyField(
      MessageLite defaultInstance, ExtensionRegistryLite extensionRegistry, ByteString bytes) {
    super(extensionRegistry, bytes);


            

Reported by PMD.

              
  @Override
  public boolean containsDefaultInstance() {
    return super.containsDefaultInstance() || value == defaultInstance;
  }

  public MessageLite getValue() {
    return getValue(defaultInstance);
  }

            

Reported by PMD.

              
  @Override
  public int hashCode() {
    return getValue().hashCode();
  }

  @Override
  public boolean equals(Object obj) {
    return getValue().equals(obj);

            

Reported by PMD.

              
  @Override
  public boolean equals(Object obj) {
    return getValue().equals(obj);
  }

  @Override
  public String toString() {
    return getValue().toString();

            

Reported by PMD.

              
  @Override
  public String toString() {
    return getValue().toString();
  }

  // ====================================================

  /**

            

Reported by PMD.

                 * from FieldSet.
   */
  static class LazyEntry<K> implements Entry<K, Object> {
    private Entry<K, LazyField> entry;

    private LazyEntry(Entry<K, LazyField> entry) {
      this.entry = entry;
    }


            

Reported by PMD.

                 * from FieldSet.
   */
  static class LazyEntry<K> implements Entry<K, Object> {
    private Entry<K, LazyField> entry;

    private LazyEntry(Entry<K, LazyField> entry) {
      this.entry = entry;
    }


            

Reported by PMD.

                    if (field == null) {
        return null;
      }
      return field.getValue();
    }

    public LazyField getField() {
      return entry.getValue();
    }

            

Reported by PMD.

                }

  static class LazyIterator<K> implements Iterator<Entry<K, Object>> {
    private Iterator<Entry<K, Object>> iterator;

    public LazyIterator(Iterator<Entry<K, Object>> iterator) {
      this.iterator = iterator;
    }


            

Reported by PMD.

                }

  static class LazyIterator<K> implements Iterator<Entry<K, Object>> {
    private Iterator<Entry<K, Object>> iterator;

    public LazyIterator(Iterator<Entry<K, Object>> iterator) {
      this.iterator = iterator;
    }


            

Reported by PMD.

              };
std::string TextFormatExtensionsTest::static_proto_debug_string_;

TEST_F(TextFormatTest, Basic) {
  TestUtil::SetAllFields(&proto_);
  EXPECT_EQ(proto_debug_string_, proto_.DebugString());
}

TEST_F(TextFormatExtensionsTest, Extensions) {

            

Reported by Cppcheck.

              class CustomUInt32FieldValuePrinter : public TextFormat::FieldValuePrinter {
 public:
  virtual std::string PrintUInt32(uint32 val) const {
    return StrCat(FieldValuePrinter::PrintUInt32(val), "u");
  }
};

TEST_F(TextFormatTest, DefaultCustomFieldPrinter) {
  protobuf_unittest::TestAllTypes message;

            

Reported by FlawFinder.

              class CustomInt32FieldValuePrinter : public TextFormat::FieldValuePrinter {
 public:
  virtual std::string PrintInt32(int32 val) const {
    return StrCat("value-is(", FieldValuePrinter::PrintInt32(val), ")");
  }
};

TEST_F(TextFormatTest, FieldSpecificCustomPrinter) {
  protobuf_unittest::TestAllTypes message;

            

Reported by FlawFinder.

              class CustomMessageFieldValuePrinter : public TextFormat::FieldValuePrinter {
 public:
  virtual std::string PrintInt32(int32 v) const {
    return StrCat(FieldValuePrinter::PrintInt32(v), "  # x",
                        strings::Hex(v));
  }

  virtual std::string PrintMessageStart(const Message& message, int field_index,
                                        int field_count,

            

Reported by FlawFinder.

                  if (single_line_mode) {
      return " { ";
    }
    return StrCat(" {  # ", message.GetDescriptor()->name(), ": ",
                        field_index, "\n");
  }
};

TEST_F(TextFormatTest, CustomPrinterForComments) {

            

Reported by FlawFinder.

                virtual std::string PrintMessageStart(const Message& message, int field_index,
                                        int field_count,
                                        bool single_line_comment) const {
    return StrCat(" {  # 1\n", "  # 2\n");
  }
};

TEST_F(TextFormatTest, CustomPrinterForMultilineComments) {
  protobuf_unittest::TestAllTypes message;

            

Reported by FlawFinder.

                  parser_.RecordErrorsTo(&error_collector);
    EXPECT_EQ(expected_result, parser_.ParseFromString(input, proto))
        << input << " -> " << proto->DebugString();
    EXPECT_EQ(StrCat(line, ":", col, ": ", message, "\n"),
              error_collector.text_);
    parser_.RecordErrorsTo(nullptr);
  }

  void ExpectSuccessAndTree(const std::string& input, Message* proto,

            

Reported by FlawFinder.

                // enum
  EXPECT_FIELD(nested_enum, unittest::TestAllTypes::BAR, "BAR");
  EXPECT_FIELD(nested_enum, unittest::TestAllTypes::BAZ,
               StrCat(unittest::TestAllTypes::BAZ));
  EXPECT_INVALID(nested_enum, "FOOBAR");

  // message
  EXPECT_TRUE(TextFormat::ParseFieldValueFromString(
      "<bb:12>", d->FindFieldByName("optional_nested_message"), message.get()));

            

Reported by FlawFinder.

                const char* format = "[$0]";
  std::string input = "\"test_value\"";
  for (int i = 0; i < 99; ++i) input = strings::Substitute(format, input);
  std::string not_deep_input = StrCat("unknown_nested_array: ", input);

  parser_.AllowUnknownField(true);
  parser_.SetRecursionLimit(100);

  unittest::NestedTestAllTypes message;

            

Reported by FlawFinder.

                ExpectSuccessAndTree(not_deep_input, &message, nullptr);

  input = strings::Substitute(format, input);
  std::string deep_input = StrCat("unknown_nested_array: ", input);
  ExpectMessage(
      deep_input,
      "WARNING:Message type \"protobuf_unittest.NestedTestAllTypes\" has no "
      "field named \"unknown_nested_array\".\n1:123: Message is too deep, the "
      "parser exceeded the configured recursion limit of 100.",

            

Reported by FlawFinder.

                @Test
  public void testPackedGeneratedMessage() throws Exception {
    TestAllTypes message = TestAllTypes.parseFrom(expectedPackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedPackedRawBytes);
  }

  @Test
  public void testPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =

            

Reported by PMD.

                @Test
  public void testPackedGeneratedMessage() throws Exception {
    TestAllTypes message = TestAllTypes.parseFrom(expectedPackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedPackedRawBytes);
  }

  @Test
  public void testPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =

            

Reported by PMD.

                public void testPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =
        DynamicMessage.parseFrom(TestAllTypes.getDescriptor(), expectedPackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedPackedRawBytes);
  }

  @Test
  public void testUnpackedGeneratedMessage() throws Exception {
    TestUnpackedTypes message = TestUnpackedTypes.parseFrom(expectedUnpackedRawBytes);

            

Reported by PMD.

                public void testPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =
        DynamicMessage.parseFrom(TestAllTypes.getDescriptor(), expectedPackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedPackedRawBytes);
  }

  @Test
  public void testUnpackedGeneratedMessage() throws Exception {
    TestUnpackedTypes message = TestUnpackedTypes.parseFrom(expectedUnpackedRawBytes);

            

Reported by PMD.

                @Test
  public void testUnpackedGeneratedMessage() throws Exception {
    TestUnpackedTypes message = TestUnpackedTypes.parseFrom(expectedUnpackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedUnpackedRawBytes);
  }

  @Test
  public void testUnPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =

            

Reported by PMD.

                @Test
  public void testUnpackedGeneratedMessage() throws Exception {
    TestUnpackedTypes message = TestUnpackedTypes.parseFrom(expectedUnpackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedUnpackedRawBytes);
  }

  @Test
  public void testUnPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =

            

Reported by PMD.

                public void testUnPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =
        DynamicMessage.parseFrom(TestUnpackedTypes.getDescriptor(), expectedUnpackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedUnpackedRawBytes);
  }

  // Make sure we haven't screwed up the code generation for packing fields by default.
  @Test
  public void testPackedSerialization() throws Exception {

            

Reported by PMD.

                public void testUnPackedDynamicMessageSerialize() throws Exception {
    DynamicMessage message =
        DynamicMessage.parseFrom(TestUnpackedTypes.getDescriptor(), expectedUnpackedRawBytes);
    assertThat(message.toByteString()).isEqualTo(expectedUnpackedRawBytes);
  }

  // Make sure we haven't screwed up the code generation for packing fields by default.
  @Test
  public void testPackedSerialization() throws Exception {

            

Reported by PMD.

                          .addRepeatedNestedEnum(NestedEnum.BAR)
            .build();

    CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());

    while (!in.isAtEnd()) {
      int tag = in.readTag();
      assertThat(WireFormat.getTagWireType(tag)).isEqualTo(WireFormat.WIRETYPE_LENGTH_DELIMITED);
      in.skipField(tag);

            

Reported by PMD.

              
    CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());

    while (!in.isAtEnd()) {
      int tag = in.readTag();
      assertThat(WireFormat.getTagWireType(tag)).isEqualTo(WireFormat.WIRETYPE_LENGTH_DELIMITED);
      in.skipField(tag);
    }
  }

            

Reported by PMD.

              public final class ExperimentalTestDataProvider {
  private static final Random RANDOM = new Random(100);

  private final Varint32Provider varint32s = new Varint32Provider();
  private final Varint64Provider varint64s = new Varint64Provider();
  private final int stringLength;

  public ExperimentalTestDataProvider(int stringLength) {
    this.stringLength = stringLength;

            

Reported by PMD.

                private static final Random RANDOM = new Random(100);

  private final Varint32Provider varint32s = new Varint32Provider();
  private final Varint64Provider varint64s = new Varint64Provider();
  private final int stringLength;

  public ExperimentalTestDataProvider(int stringLength) {
    this.stringLength = stringLength;
  }

            

Reported by PMD.

              
  private final Varint32Provider varint32s = new Varint32Provider();
  private final Varint64Provider varint64s = new Varint64Provider();
  private final int stringLength;

  public ExperimentalTestDataProvider(int stringLength) {
    this.stringLength = stringLength;
  }


            

Reported by PMD.

                   * The index into the {@link #VALUES} array that identifies the list of samples currently being
     * iterated over.
     */
    private int listIndex;

    /** The index of the next sample within a list. */
    private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */

            

Reported by PMD.

                  private int listIndex;

    /** The index of the next sample within a list. */
    private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */
    private int samplesTaken;

    public int getInt() {

            

Reported by PMD.

                  private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */
    private int samplesTaken;

    public int getInt() {
      if (samplesTaken++ > NUM_SAMPLES[listIndex]) {
        // Done taking samples from this list. Go to the next one.
        listIndex = (listIndex + 1) % VALUES.length;

            

Reported by PMD.

                  private int samplesTaken;

    public int getInt() {
      if (samplesTaken++ > NUM_SAMPLES[listIndex]) {
        // Done taking samples from this list. Go to the next one.
        listIndex = (listIndex + 1) % VALUES.length;
        sampleIndex = 0;
        samplesTaken = 0;
      }

            

Reported by PMD.

                   * The index into the {@link #VALUES} array that identifies the list of samples currently being
     * iterated over.
     */
    private int listIndex;

    /** The index of the next sample within a list. */
    private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */

            

Reported by PMD.

                  private int listIndex;

    /** The index of the next sample within a list. */
    private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */
    private int samplesTaken;

    public long getLong() {

            

Reported by PMD.

                  private int sampleIndex;

    /** The number of successive samples that have been taken from the current list. */
    private int samplesTaken;

    public long getLong() {
      if (samplesTaken++ > NUM_SAMPLES[listIndex]) {
        // Done taking samples from this list. Go to the next one.
        listIndex = (listIndex + 1) % VALUES.length;

            

Reported by PMD.

                    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
      return flat.data();
    } else {
      std::memcpy(buffer_, flat.data(), flat.size());
      limit_ = 0;
      limit_end_ = buffer_end_ = buffer_ + flat.size();
      next_chunk_ = nullptr;
      if (aliasing_ == kOnPatch) {
        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -

            

Reported by FlawFinder.

                int size_;
  int limit_;  // relative to buffer_end_;
  io::ZeroCopyInputStream* zcis_ = nullptr;
  char buffer_[2 * kSlopBytes] = {};
  enum { kNoAliasing = 0, kOnPatch = 1, kNoDelta = 2 };
  std::uintptr_t aliasing_ = kNoAliasing;
  // This variable is used to communicate how the parse ended, in order to
  // completely verify the parsed data. A wire-format parse can end because of
  // one of the following conditions:

            

Reported by FlawFinder.

                  return *ptr == static_cast<char>(tag);
  } else {
    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
    return std::memcmp(ptr, buf, 2) == 0;
  }
}

template <int>

            

Reported by FlawFinder.

              struct EndianHelper<2> {
  static uint16_t Load(const void* p) {
    uint16_t tmp;
    std::memcpy(&tmp, p, 2);
#ifndef PROTOBUF_LITTLE_ENDIAN
    tmp = bswap_16(tmp);
#endif
    return tmp;
  }

            

Reported by FlawFinder.

              struct EndianHelper<4> {
  static uint32_t Load(const void* p) {
    uint32_t tmp;
    std::memcpy(&tmp, p, 4);
#ifndef PROTOBUF_LITTLE_ENDIAN
    tmp = bswap_32(tmp);
#endif
    return tmp;
  }

            

Reported by FlawFinder.

              struct EndianHelper<8> {
  static uint64_t Load(const void* p) {
    uint64_t tmp;
    std::memcpy(&tmp, p, 8);
#ifndef PROTOBUF_LITTLE_ENDIAN
    tmp = bswap_64(tmp);
#endif
    return tmp;
  }

            

Reported by FlawFinder.

              T UnalignedLoad(const char* p) {
  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  T res;
  memcpy(&res, &tmp, sizeof(T));
  return res;
}

PROTOBUF_EXPORT
std::pair<const char*, uint32_t> VarintParseSlow32(const char* p, uint32_t res);

            

Reported by FlawFinder.

                  int block_size = num * sizeof(T);
    auto dst = out->AddNAlreadyReserved(num);
#ifdef PROTOBUF_LITTLE_ENDIAN
    std::memcpy(dst, ptr, block_size);
#else
    for (int i = 0; i < num; i++)
      dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
#endif
    size -= block_size;

            

Reported by FlawFinder.

                int block_size = num * sizeof(T);
  auto dst = out->AddNAlreadyReserved(num);
#ifdef PROTOBUF_LITTLE_ENDIAN
  std::memcpy(dst, ptr, block_size);
#else
  for (int i = 0; i < num; i++) dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
#endif
  ptr += block_size;
  if (size != block_size) return nullptr;

            

Reported by FlawFinder.

                    // The current buffer contains all the information needed, we don't need
      // to flip buffers. However we must parse from a buffer with enough space
      // so we are not prone to a buffer overflow.
      char buf[kSlopBytes + 10] = {};
      std::memcpy(buf, buffer_end_, kSlopBytes);
      GOOGLE_CHECK_LE(size - chunk_size, kSlopBytes);
      auto end = buf + (size - chunk_size);
      auto res = ReadPackedVarintArray(buf + overrun, end, add);
      if (res == nullptr || res != end) return nullptr;

            

Reported by FlawFinder.