fout.close

    now = int(time.time())
    payload = {
        # expire in one hour.
        "exp": now + args.expire,
        "iat": now,
    }
    if args.iss:
        payload["iss"] = args.iss
    if args.sub:
        payload["sub"] = args.sub
    else:
        payload["sub"] = args.iss

    if args.aud:
        if "," in args.aud:
            payload["aud"] = args.aud.split(",")
        else:

        }
    }

    public @Nullable Object deserialize(SerializedPayload payload) {
        if (payload.getSerializedModel().isEmpty()) {
            return null;
        }

        final DeserializeMap map = classLoaderRegistry.newDeserializeSession();
        try {
            final Map<Short, ClassLoaderDetails> classLoaderDetails = Cast.uncheckedNonnullCast(payload.getHeader());

            BuildModelAction buildModelAction = (BuildModelAction) action;
            Object payload = buildModelAction.getModelName();
            return new QueryModelRequirements(action.getStartParameter(), action.isRunTasks(), payloadHashProvider(payload));
        } else if (action instanceof ClientProvidedBuildAction) {
            SerializedPayload payload = ((ClientProvidedBuildAction) action).getAction();

	errFatal(local.RegisterSingleHandler(handlerTest, func(payload []byte) ([]byte, *RemoteErr) {
		t.Log("1: server payload: ", len(payload), "bytes.")
		return append([]byte{}, payload...), nil
	}))
	// 2: Return as error
	errFatal(local.RegisterSingleHandler(handlerTest2, func(payload []byte) ([]byte, *RemoteErr) {
		t.Log("2: server payload: ", len(payload), "bytes.")
		err := RemoteErr(payload)
		return nil, &err
	}))

        messages[0].payload == "payload"
        messages[1] instanceof EndOfStream
     }

    def "does not discard queued outgoing messages when stop requested until all connections finished"() {
        def channel = new ChannelIdentifier("channel")
        def message = new ChannelMessage(channel, "payload")
        def sentinel = new ChannelMessage(channel, "payload")

        given:

				t.Errorf("%v: unexpected failure making payload: %v", tc.name, err)
				return
			}
			if err == nil && !tc.success {
				t.Errorf("%v: unexpected success making payload", tc.name)
				return
			}
			if !tc.success {
				return
			}
			if e, a := tc.payload, actualPayload; !reflect.DeepEqual(e, a) {
				t.Errorf("%v: expected and actual payload do not match", tc.name)
			}
		})
	}
}

func (c *Connection) sendMsg(conn net.Conn, msg message, payload msgp.MarshalSizer) error {
	if payload != nil {
		if sz := payload.Msgsize(); cap(msg.Payload) < sz {
			PutByteBuffer(msg.Payload)
			msg.Payload = GetByteBufferCap(sz)[:0]
		}
		var err error
		msg.Payload, err = payload.MarshalMsg(msg.Payload)
		if err != nil {
			return err
		}
		defer PutByteBuffer(msg.Payload)
	}
	dst := GetByteBufferCap(msg.Msgsize())

              filter: envoy.filters.http.jwt_authn
              path:
              - key: payload
              - key: iss
              value:
                string_match:
                  safe_regex: {regex: .+}
          - metadata:
              filter: envoy.filters.http.jwt_authn
              path:
              - key: payload
              - key: sub
              value:
                string_match:

        when:
        String actual = null
        wrap({ String payload -> actual = payload }).accept("lajos")
        then:
        actual == "lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ String payload ->
            assert payload == "lajos"
            throw exception
        }).accept("lajos")
    }

// from the end of payload. It also returns a byte which is equal to 255 if the
// padding was valid and 0 otherwise. See RFC 2246, Section 6.2.3.2.
func extractPadding(payload []byte) (toRemove int, good byte) {
	if len(payload) < 1 {
		return 0, 0
	}

	paddingLen := payload[len(payload)-1]
	t := uint(len(payload)-1) - uint(paddingLen)
	// if len(payload) >= (paddingLen - 1) then the MSB of t is zero