StringBuilder msg = new StringBuilder(message);
        problems.problems().forEach(problem -> msg.append("\n * ")
                .append(problem.getSeverity().name())
                .append(": ")
                .append(problem.getMessage()));
        return msg.toString();
    }

    /**
     * Returns the problem collector associated with this exception.
     *

func (s *scratch) grow() {
	ndata := make([]byte, cap(s.data)*2)
	copy(ndata, s.data)
	s.data = ndata
}

// append single byte to scratch buffer
func (s *scratch) add(c byte) {
	if s.fill+1 >= cap(s.data) {
		s.grow()
	}

	s.data[s.fill] = c
	s.fill++
}

// append encoded rune to scratch buffer
func (s *scratch) addRune(r rune) int {
	if s.fill+utf8.UTFMax >= cap(s.data) {
		s.grow()
	}

	return sql.FromBytes([]byte(r.csvRecord[index])), nil
}

// Set - sets the value for a column name.
func (r *Record) Set(name string, value *sql.Value) (sql.Record, error) {
	r.columnNames = append(r.columnNames, name)
	r.csvRecord = append(r.csvRecord, value.CSVString())
	return r, nil
}

// Reset data in record.
func (r *Record) Reset() {
	if len(r.columnNames) > 0 {
		r.columnNames = r.columnNames[:0]
	}

			// delete this version leading to a free version
			xl.DeleteVersion(fi)
			freeVersionIDs = append(freeVersionIDs, fi.TierFreeVersionID())
			allVersionIDs = append(allVersionIDs, fi.TierFreeVersionID())
		} else {
			versions = append(versions, fi)
			allVersionIDs = append(allVersionIDs, fi.VersionID)
		}
	}
	buf, err := xl.AppendTo(nil)
	if err != nil {

      }

      @Override
      public String getExpected(String data) {
        /*
         * Get what the byte sink factory would expect for no written bytes, then append expected
         * string to that.
         */
        byte[] factoryExpectedForNothing = factory.getExpected(new byte[0]);
        return new String(factoryExpectedForNothing, UTF_8) + checkNotNull(data);
      }

     * @return new referral, combining a chain of referrals
     */
    DfsReferralDataInternal combine(DfsReferralData next);

    /**
     * Append another referral to this referral chain
     *
     * @param dr the referral to append
     */
    void append(DfsReferralDataInternal dr);

	var tokens []Token
	for _, tok := range macro.tokens {
		if tok.ScanToken != scanner.Ident {
			tokens = append(tokens, tok)
			continue
		}
		substitution := actuals[tok.text]
		if substitution == nil {
			tokens = append(tokens, tok)
			continue
		}
		tokens = append(tokens, substitution...)
	}
	in.Push(NewSlice(in.Base(), in.Line(), tokens))
}

    protected static String wrapQuery(final String query) {
        final StringBuilder sb = new StringBuilder();
        if (!query.startsWith("*")) {
            sb.append("*");
        }
        sb.append(query);
        if (!query.endsWith("*")) {
            sb.append("*");
        }
        return sb.toString();
    }

        assertNotNull(referral, "The DfsReferral object should not be null.");
        assertEquals(referral, referral.next, "The 'next' property should point to the object itself.");
    }

    /**
     * Tests the append method of the DfsReferral class.
     * It verifies that a new DfsReferral object can be successfully appended to an existing one,
     * forming a linked list structure.
     */
    @Test
    void testAppend() {

    discussion_edges = get_graphql_question_discussion_edges(settings=settings)

    while discussion_edges:
        for discussion_edge in discussion_edges:
            discussion_nodes.append(discussion_edge.node)
        last_edge = discussion_edges[-1]
        # Handle GitHub secondary rate limits, requests per minute
        time.sleep(settings.sleep_interval)