/**
 * Simplified from
 * https://hc.apache.org/httpcomponents-client-5.0.x/httpclient5/examples/AsyncClientTlsAlpn.java
 *
 * Mainly intended to verify behaviour of popular clients across Android versions, similar
 * to observing Firefox or Chrome browser behaviour.
 */
@Ignore("Failing with Netty errors")
class ApacheHttpClientHttp2Test {
  @Test
  fun testHttp2() {
    val client = HttpAsyncClients.createHttp2Default()

    for (Field field : HttpHeaders.class.getDeclaredFields()) {
      /*
       * Coverage mode generates synthetic fields.  If we ever add private
       * fields, they will cause similar problems, and we may want to switch
       * this check to isAccessible().
       */
      if (!field.isSynthetic() && field.getType() == String.class) {
        builder.add(field);
      }
    }

 * sum that is used for purposes such as collecting statistics, not for fine-grained synchronization
 * control. Under low update contention, the two classes have similar characteristics. But under
 * high contention, expected throughput of this class is significantly higher, at the expense of
 * higher space consumption.
 *

        assertTrue("File directly in base directory should be allowed", result);
    }

    @Test
    public void test_isValidUploadPath_edgeCase_similarPrefix() throws Exception {
        // Test directory with similar prefix (images vs images2)
        File baseDir = new File(tempDir.toFile(), "images");
        baseDir.mkdirs();
        File similarDir = new File(tempDir.toFile(), "images2");
        similarDir.mkdirs();

		return nil, &os.PathError{
			Op:   "open",
			Path: path,
			Err:  syscall.EISDIR,
		}
	}

	return &LockedFile{f}, nil
}

// TryLockedOpenFile - tries a new write lock, functionality
// it is similar to LockedOpenFile with with syscall.LOCK_EX
// mode but along with syscall.LOCK_NB such that the function
// doesn't wait forever but instead returns if it cannot
// acquire a write lock.

### Always `raise` in Dependencies with `yield` and `except` { #always-raise-in-dependencies-with-yield-and-except }

If you catch an exception in a dependency with `yield`, unless you are raising another `HTTPException` or similar, **you should re-raise the original exception**.

func NewRecord(f sql.SelectObjectFormat) *Record {
	return &Record{
		KVS:          jstream.KVS{},
		SelectFormat: f,
	}
}

// jsonFloat converts a float to string similar to Go stdlib formats json floats.
func jsonFloat(f float64) string {
	var tmp [32]byte
	dst := tmp[:0]

	// Convert as if by ES6 number to string conversion.
	// This matches most other JSON generators.

   * with a differently behaving {@code loader}. For example, a call that requests a short timeout
   * for an RPC may wait for a similar call that requests a long timeout, or a call by an
   * unprivileged user may return a resource accessible only to a privileged user making a similar
   * call. To prevent this problem, create a key object that includes all values that affect the

          sb.append(DELIMITER_STRING);
        }
        sb.append(comp);
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

  /**
   * Similar to the above, but keeps a boolean flag rather than checking for the string accumulated
   * so far being empty. As a result, it does not have the above-mentioned bug.
   */
  @Benchmark
  int booleanIfFirst(int reps) {

@GwtCompatible
abstract class CollectionFuture<V extends @Nullable Object, C extends @Nullable Object>
    extends AggregateFuture<V, C> {
  /*
   * We access this field racily but safely. For discussion of a similar situation, see the comments
   * on the fields of TimeoutFuture. This field is slightly different from the fields discussed
   * there: cancel() never reads this field, only writes to it. That makes the race here completely