return false;
          }

          @Override
          public boolean isDone() {
            return true;
          }

          @Override
          public boolean isCancelled() {
            return true; // BAD!!
          }

          @Override
          public String get() {
            return "foo"; // BAD!!
          }

          @Override

                  created = true;
                }
              } finally {
                busy = 0;
              }
              if (created) break;
              continue; // Slot is now non-empty
            }
          }
          collide = false;
        } else if (!wasUncontended) // CAS already known to fail
        wasUncontended = true; // Continue after rehash

          return false;
        }
        prev = next;
      }
    }
    return true;
  }

  /**
   * Returns {@code true} if each element in {@code iterable} after the first is <i>strictly</i>
   * greater than the element that preceded it, according to the specified comparator. Note that
   * this is always true when the iterable has fewer than two elements.
   */

		return nil
	}

	optsMap := make(map[string]string)
	if opts.LockEnabled {
		optsMap["lockEnabled"] = "true"
		optsMap["versioningEnabled"] = "true"
	}
	if opts.VersioningEnabled {
		optsMap["versioningEnabled"] = "true"
	}
	if opts.ForceCreate {
		optsMap["forceCreate"] = "true"
	}
	createdAt, _ := globalBucketMetadataSys.CreatedAt(bucket)
	optsMap["createdAt"] = createdAt.UTC().Format(time.RFC3339Nano)

        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.versionedGraph)) {
            return new MetadataGraph(getTree(), true, false);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.scopedGraph)) {
            return new MetadataGraph(getTree(), true, true);
        }
        return null;
    }
    // ----------------------------------------------------------------------------

}
```

### 7.2 Integration Tests
```java
@Test
@EnabledIfSystemProperty(named = "rdma.test.enabled", matches = "true")
public void testRdmaLargeFileTransfer() throws Exception {
    CIFSContext context = getTestContext();
    context.getConfig().setProperty("jcifs.smb.client.useRDMA", "true");
    
    SmbFile file = new SmbFile("smb://server/share/largefile.dat", context);
    
    // Measure RDMA transfer performance

     *
     * @return true if the context handle has been invalidated
     */
    public boolean isContextHandleInvalidated() {
        if (contextHandle == null) {
            return true;
        }

        for (byte b : contextHandle) {
            if (b != 0) {
                return false;
            }
        }
        return true;
    }

	if ct.LengthValue.Valid {
		return ct.LengthValue.Int64, true
	}
	return ct.SQLColumnType.Length()
}

// DecimalSize returns the scale and precision of a decimal type.
func (ct ColumnType) DecimalSize() (precision int64, scale int64, ok bool) {
	if ct.DecimalSizeValue.Valid {
		return ct.DecimalSizeValue.Int64, ct.ScaleValue.Int64, true
	}
	return ct.SQLColumnType.DecimalSize()
}

	if *flagCheck {
		// not worth repeating in -check
		t.Skip("skipping with -check set")
	}

	tests := []struct {
		pkg  string
		want bool
	}{
		{"net/http", true},
		{"net/http/internal-foo", true},
		{"net/http/internal", false},
		{"net/http/internal/bar", false},
		{"internal/foo", false},
		{"internal", false},
	}
	for _, tt := range tests {

@GwtCompatible
@NullUnmarked
public class TreeBasedTableRowMapInterfaceTest extends SortedMapInterfaceTest<String, String> {
  public TreeBasedTableRowMapInterfaceTest() {
    super(false, false, true, true, true);
  }

  @Override
  protected SortedMap<String, String> makeEmptyMap() {
    TreeBasedTable<String, String, String> table = TreeBasedTable.create();
    table.put("a", "b", "c");
    table.put("c", "b", "a");