* @param first the first element
   * @param second the second element
   * @param rest an array of additional elements, possibly empty
   * @return an unmodifiable list containing the specified elements
   */
  public static <E extends @Nullable Object> List<E> asList(
      @ParametricNullness E first, @ParametricNullness E second, E[] rest) {
    return new TwoPlusArrayList<>(first, second, rest);
  }

  /**

	mg := &MetricsGroupV2{
		cacheInterval: 10 * time.Second,
	}
	mg.RegisterRead(func(ctx context.Context) []MetricV2 {
		return getHistogramMetrics(bucketHTTPRequestsDuration,
			getBucketTTFBDistributionMD(), true, true)
	})
	return mg
}

func getS3TTFBMetric() *MetricsGroupV2 {
	mg := &MetricsGroupV2{
		cacheInterval: 10 * time.Second,
	}
	mg.RegisterRead(func(ctx context.Context) []MetricV2 {

        testData.add(createRelatedQuery("test", new String[] { "second", "set" }, ""));
        mockBhv.setTestData(testData);

        relatedQueryHelper.load();

        // The second entry should overwrite the first one
        String[] results = relatedQueryHelper.getRelatedQueries("test");
        assertEquals(2, results.length);
        assertEquals("second", results[0]);
        assertEquals("set", results[1]);
    }

      } catch (TimeoutException tryHarder) {
        /* OK */
      }
    } while (System.nanoTime() - deadline < 0);
    throw formatRuntimeException("Future not done within %d second timeout", timeoutSeconds);
  }

  /**
   * Waits until the given predicate returns true, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *

        return ordinal() <= v.ordinal();
    }

    /**
     * Get the minimum of two dialect versions
     *
     * @param a the first version to compare
     * @param b the second version to compare
     * @return smaller of the two versions
     */
    public static DialectVersion min(final DialectVersion a, final DialectVersion b) {
        if (a.atMost(b)) {
            return a;
        }

            @Override
            public RescorerBuilder<?> evaluate(Map<String, Object> params) {
                return createMockRescorerBuilder();
            }
        };

        // Test with second implementation
        QueryRescorer rescorer2 = new QueryRescorer() {
            @Override
            public RescorerBuilder<?> evaluate(Map<String, Object> params) {
                return null;
            }

pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0
pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
pkg p4, method (Pair[$0, $1]) First() $0
pkg p4, method (Pair[$0, $1]) Second() $1

  }

  /**
   * Test to ensure we throw a read timeout on responses that are progressing too slowly.  For this
   * case, we take a 2KiB body and throttle it to 1KiB/second.  We set the read timeout to half a
   * second.  If our implementation is acting correctly, it will throw, as a byte doesn't arrive in
   * time.
   */
  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)

     * SMB server addressed by the URL parameter. See {@link jcifs.smb1.smb1.SmbFile}
     * for a detailed description and examples of the smb URL syntax. If the
     * second argument is <code>true</code>, then bytes will be written to the
     * end of the file rather than the beginning.
     *
     * @param url An smb URL string representing the file to write to

        assertEquals(2, callbackResults.size());
        assertEquals("integration test", callbackResults.get(0));
        assertEquals("second line", callbackResults.get(1));

        String output = thread.getOutput();
        assertTrue(output.contains("integration test"));
        assertTrue(output.contains("second line"));
    }

    public void test_defaultBufferSizeConstant() throws IOException {