sink.putInt(0x04030201);
    HashCode unused = sink.hash();
    sink.assertInvariants(4);
    sink.assertBytes(new byte[] {1, 2, 3, 4});
  }

  public void testLong() {
    Sink sink = new Sink(8);
    sink.putLong(0x0807060504030201L);
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8});
  }

  public void testChar() {
    Sink sink = new Sink(4);

        for (PrimitiveSink sink : sinks) {
          sink.putInt(value);
        }
      }
    },
    PUT_LONG() {
      @Override
      void performAction(Random random, Iterable<? extends PrimitiveSink> sinks) {
        long value = random.nextLong();
        for (PrimitiveSink sink : sinks) {
          sink.putLong(value);
        }
      }
    },
    PUT_FLOAT() {
      @Override

        // Capability (4 bytes)
        bb.putInt(capability);

        // Reserved (4 bytes) - must be 0
        bb.putInt(0);

        // LinkSpeed (8 bytes) - in bits per second
        bb.putLong((long) linkSpeed * 1000000L);

        // SockAddr_Storage (128 bytes)
        encodeSockaddr(buffer, 24);

        return buffer;
    }

    /**
     * Parse network interface info from encoded bytes

            final long counter = this.nonceCounter.incrementAndGet();
            final ByteBuffer buffer = ByteBuffer.wrap(nonce);
            buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(counter);
            // Remaining bytes (if any) stay zero-padded
        }

        return nonce;
    }

    /**
     * Generate a secure random nonce for initial session setup.

            }
            baos.write(channel.getLocalInterface().getAddress().getAddress());
            baos.write(channel.getRemoteInterface().getAddress().getAddress());
            baos.write(ByteBuffer.allocate(8).putLong(System.currentTimeMillis()).array());
        } catch (IOException e) {
            // Should not happen with ByteArrayOutputStream
            log.error("Error creating binding info", e);
        }

  }

  private static final class CustomFunnel implements Funnel<Long> {
    @Override
    public void funnel(Long value, PrimitiveSink into) {
      into.putLong(value);
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return object instanceof CustomFunnel;
    }

    @Override
    public int hashCode() {
      return 42;

    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,
        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    buffer
        .putLong(count)
        .putDouble(mean)
        .putDouble(sumOfSquaresOfDeltas)
        .putDouble(min)
        .putDouble(max);
  }

  /**

        result);
    return (int) result;
  }

  /**
   * Returns a big-endian representation of {@code value} in an 8-element byte array; equivalent to
   * {@code ByteBuffer.allocate(8).putLong(value).array()}. For example, the input value {@code
   * 0x1213141516171819L} would yield the byte array {@code {0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
   * 0x18, 0x19}}.
   *

		t.Fatalf("bytepool size invalid: got %v want %v", len(bp.c), size)
	}

	// lets drain the buf channel first before we validate invalid buffers.
	for range size {
		bp.Get() // discard
	}

	// Try putting some invalid buffers into pool
	bp.Put(make([]byte, bp.w, bp.wcap-1)) // wrong capacity is rejected (less)
	bp.Put(make([]byte, bp.w, bp.wcap+1)) // wrong capacity is rejected (more)

## What Does Deployment Mean { #what-does-deployment-mean }

To **deploy** an application means to perform the necessary steps to make it **available to the users**.

For a **web API**, it normally involves putting it in a **remote machine**, with a **server program** that provides good performance, stability, etc, so that your **users** can **access** the application efficiently and without interruptions or problems.