}
}

// postPresignSignatureV4 - presigned signature for PostPolicy requests.
func postPresignSignatureV4(policyBase64 string, t time.Time, secretAccessKey, location string) string {
	// Get signining key.
	signingkey := getSigningKey(secretAccessKey, t, location, "s3")
	// Calculate signature.
	signature := getSignature(signingkey, policyBase64)
	return signature
}

      .isEqualTo(javaCertificate.signature.toByteString())

    assertThat(okHttpCertificate).isEqualTo(
      Certificate(
        tbsCertificate =
          TbsCertificate(
            // v3.
            version = 2L,
            serialNumber = BigInteger("1372799044"),
            signature =
              AlgorithmIdentifier(

robolectric-android = "org.robolectric:android-all:14-robolectric-10818077"
robolectric = "org.robolectric:robolectric:4.12.1"
signature-android-apilevel21 = "net.sf.androidscents.signature:android-api-level-21:5.0.1_r2"
signature-android-apilevel24 = "net.sf.androidscents.signature:android-api-level-24:7.0_r2"
squareup-moshi = { module = "com.squareup.moshi:moshi", version.ref = "com-squareup-moshi" }

            .firstOrNull { it.getSymbolPointerSignature() == signature }
            ?.toKtCallableSymbol(analysisContext) as? T
    }

    override fun pointsToTheSameSymbolAs(other: KtSymbolPointer<KtSymbol>): Boolean = this === other ||
            other is KtFe10DescFunctionLikeSymbolPointer &&
            other.callableId == callableId &&
            other.signature == signature

	tmp := struct {
		VersionID string
		ModTime   time.Time
		Signature string
		Type      uint8
		Flags     uint8
	}{
		VersionID: hex.EncodeToString(z.VersionID[:]),
		ModTime:   time.Unix(0, z.ModTime),
		Signature: hex.EncodeToString(z.Signature[:]),
		Type:      z.Type,
		Flags:     z.Flags,
	}
	return json.Marshal(tmp)

            }

            byte[] type1 = new byte[size];
            int pos = 0;

            System.arraycopy(NTLMSSP_SIGNATURE, 0, type1, 0, NTLMSSP_SIGNATURE.length);
            pos += NTLMSSP_SIGNATURE.length;

            writeULong(type1, pos, NTLMSSP_TYPE1);
            pos += 4;

            writeULong(type1, pos, flags);
            pos += 4;

    constructorsSupplier.get().firstOrNull { c -> jvmSignature == c.signature?.asString() }?.flags?.let { predicate(it) } ?: false


private
fun hasFunctionFlags(functionsSupplier: Supplier<MutableList<KmFunction>>, jvmSignature: String, predicate: FlagsPredicate) =
    functionsSupplier.get().firstOrNull {
        jvmSignature == it.signature?.asString()
    }?.flags?.let { predicate(it) } ?: false


private

     * is somehow changed, then we want to keep the wrapper.
     *
     * Such substitute overrides happen because of inheritance.
     *
     * If the declaration references only its own type parameters, or parameters from the outer declarations, then

	type testCase struct {
		req   *http.Request
		authT authType
	}
	nopCloser := io.NopCloser(io.LimitReader(&nullReader{}, 1024))
	testCases := []testCase{
		// Test case - 1
		// Check for generic signature v4 header.
		{
			req: &http.Request{
				URL: &url.URL{
					Host:   "127.0.0.1:9000",
					Scheme: httpScheme,
					Path:   SlashSeparator,
				},
				Header: http.Header{

import spock.lang.Specification

class ParameterMetaDataTest extends Specification {
    def "formats signature"() {
        MethodMetaData method = Mock()
        def parameter = new ParameterMetaData('param')
        def type = new TypeMetaData('org.gradle.SomeType')
        parameter.type = type

        expect:
        parameter.signature == 'org.gradle.SomeType param'
    }