//
  if (b != address.size) {
    if (compress == -1) return null // Address didn't have compression or enough groups.
    address.copyInto(address, address.size - (b - compress), compress, b)
    address.fill(0.toByte(), compress, compress + (address.size - b))
  }

  return address
}

/** Decodes an IPv4 address suffix of an IPv6 address, like 1111::5555:6666:192.168.0.1. */

    def "has useful display name"() {
        def address = new SocketInetAddress(localhost, 234)

        expect:
        address.displayName == "localhost/${localhost.hostAddress}:234"
        address.toString() == "localhost/${localhost.hostAddress}:234"
    }

    def "equal when address and port are equal"() {
        def address = new SocketInetAddress(localhost, 234)

// A sockaddr represents a TCP, UDP, IP or Unix network endpoint
// address that can be converted into a syscall.Sockaddr.
type sockaddr interface {
	Addr

	// family returns the platform-dependent address family
	// identifier.
	family() int

	// isWildcard reports whether the address is a wildcard
	// address.
	isWildcard() bool

	// sockaddr returns the address converted into a syscall

	fmt.Printf("Email: %v\n", v.Email)
	fmt.Printf("Groups: %v\n", v.Groups)
	fmt.Printf("Address: %v\n", v.Address)
	// Output:
	// XMLName: xml.Name{Space:"", Local:"Person"}
	// Name: "Grace R. Emlin"
	// Phone: "none"
	// Email: [{home ******@****.***} {work ******@****.***}]
	// Groups: [Friends Squash]
	// Address: {Hanga Roa Easter Island}

        @Override
        public void write(Encoder encoder, SocketInetAddress address) throws Exception {
            writeAddress(encoder, address);
            encoder.writeInt(address.port);
        }

        private void writeAddress(Encoder encoder, SocketInetAddress address) throws IOException {
            encoder.writeBinary(address.address.getAddress());
        }
    }

    def "marks idle"() {
        given:
        updater.onStart(address)

        when:
        updater.onCompleteActivity()

        then:
        1 * registry.markState(address, Idle)
    }

    def "ignores empty cache on marking idle"() {
        given:
        updater.onStart(address)
        registry.markState(address, Idle) >> { throw new EmptyRegistryException("") }

        when:

     * NetBIOS address. This provides a way to retrieve the other names for a
     * host with the same IP address.
     *
     * @param addr
     *            the address to query
     * @return resolved addresses
     * @throws UnknownHostException
     *             if address cannot be resolved
     */
    NetbiosAddress[] getNbtAllByAddress ( NetbiosAddress addr ) throws UnknownHostException;


    /**

      - suffix: -not-ns-suffix
      - presence: {}
- rules:
  - matches:
    - notSourceIps:
      - address: AgIDBA==
        length: 32
      - address: BgYAAA==
        length: 16
      sourceIps:
      - address: AQIDBA==
        length: 32
      - address: BQYAAA==
        length: 16
- rules:
  - matches:
    - destinationPorts:
      - 80
      - 90
      notDestinationPorts:

			inFilter: &ListenerFilter{
				Address: "0.0.0.0",
			},
			inListener: &listener.Listener{
				Address: &core.Address{
					Address: &core.Address_SocketAddress{
						SocketAddress: &core.SocketAddress{Address: "1.1.1.1"},
					},
				},
				AdditionalAddresses: []*listener.AdditionalAddress{
					{
						Address: &core.Address{
							Address: &core.Address_SocketAddress{

   *
   * @param hostAddr an RFC 3986 section 3.2.2 encoded IPv4 or IPv6 address
   * @return an InetAddress representing the address in {@code hostAddr}
   * @throws IllegalArgumentException if {@code hostAddr} is not a valid IPv4 address, or IPv6
   *     address surrounded by square brackets, or if the address has a scope id that fails
   *     validation against interfaces on the machine
   */