* <p>Calling {@code setDistinctValues(type, v1, v2)} also sets the default value for {@code type}
   * that's used for {@link #testNulls}.
   *
   * <p>Only necessary for types where {@link ClassSanityTester} doesn't already know how to create
   * distinct values.
   *
   * @return this tester instance
   * @since 17.0
   */
  @CanIgnoreReturnValue
  public <T> ClassSanityTester setDistinctValues(Class<T> type, T value1, T value2) {

     * we can reference a node whose fields have been cleared is inside the iterator (and presumably
     * only under concurrent modification).
     *
     * To access these fields when you know that they are not null, call the pred() and succ()
     * methods, which perform null checks before returning the fields.
     */
    @CheckForNull private AvlNode<E> pred;
    @CheckForNull private AvlNode<E> succ;

    if (!iterator.hasNext()) {
      return Optional.absent();
    }

    /*
     * TODO(kevinb): consider whether this "optimization" is worthwhile. Users with SortedSets tend
     * to know they are SortedSets and probably would not call this method.
     */
    if (iterable instanceof SortedSet) {
      SortedSet<E> sortedSet = (SortedSet<E>) iterable;
      return Optional.of(sortedSet.last());
    }

index c9bf593..f461fc1 100644
--- a/string/bits/string2.h
+++ b/string/bits/string2.h
@@ -47,29 +47,7 @@
 #endif
 
 #if _STRING_ARCH_unaligned
-/* If we can do unaligned memory accesses we must know the endianess.  */
-# include <endian.h>
 # include <bits/types.h>
-
-# if __BYTE_ORDER == __LITTLE_ENDIAN
-#  define __STRING2_SMALL_GET16(src, idx) \

It has an integrated dependency injection system, inspired by Angular 2. It requires pre-registering the "injectables" (like all the other dependency injection systems I know), so, it adds to the verbosity and code repetition.

As the parameters are described with TypeScript types (similar to Python type hints), editor support is quite good.

// name xxx for the references C.xxx in the Go input.
// The kind is either a constant, type, or variable.
func (p *Package) guessKinds(f *File) []*Name {
	// Determine kinds for names we already know about,
	// like #defines or 'struct foo', before bothering with gcc.
	var names, needType []*Name
	optional := map[*Name]bool{}
	for _, key := range nameKeys(f.Name) {
		n := f.Name[key]

   *     {@code off + len} is greater than {@code b.length}
   */
  @CanIgnoreReturnValue
  // Sometimes you don't care how many bytes you actually read, I guess.
  // (You know that it's either going to read len bytes or stop at EOF.)
  public static int read(InputStream in, byte[] b, int off, int len) throws IOException {
    checkNotNull(in);
    checkNotNull(b);
    if (len < 0) {

     * we can reference a node whose fields have been cleared is inside the iterator (and presumably
     * only under concurrent modification).
     *
     * To access these fields when you know that they are not null, call the pred() and succ()
     * methods, which perform null checks before returning the fields.
     */
    @CheckForNull private AvlNode<E> pred;
    @CheckForNull private AvlNode<E> succ;

		for _, op := range ops {
			switch op {
			case madmin.CredentialsUpdateType:
				if !globalSiteReplicationSys.isEnabled() {
					// credentials update is possible only in bucket replication. User will never
					// know the site replicator creds.
					tgt.Credentials = target.Credentials
					tgt.TargetBucket = target.TargetBucket
					tgt.Secure = target.Secure
					tgt.Endpoint = target.Endpoint
				}

you should first check whether the call succeeded before checking the error
result. For example:

	n, err := C.setenv(key, value, 1)
	if n != 0 {
		// we know the call failed, so it is now valid to use err
		return err
	}

Calling C function pointers is currently not supported, however you can
declare Go variables which hold C function pointers and pass them