Double generateDoubleObject() {
    return new Double(generateDouble());
  }

  @Generates
  short generateShort() {
    return (short) generateInt();
  }

  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
  @Generates
  Short generateShortObject() {
    return new Short(generateShort());
  }

  @Generates
  byte generateByte() {
    return (byte) generateInt();
  }

Use the following forms in your markdown:

	[http.Request]                     # symbol documentation; auto-linked as in Go doc strings
	[Request]                          # short form, for symbols in the package being documented
	[net/http]                         # package link
	[#12345](/issue/12345)             # GitHub issues
	[CL 6789](/cl/6789)                # Gerrit changelists

        } catch (NullPointerException e) {
            // Expected
        }
    }

    public void test_getDetectText_shortText() {
        String text = "Short text";
        String result = languageHelper.getDetectText(text);
        assertEquals("Short text", result);
    }

    public void test_getDetectText_longText() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1100; i++) {

#

### BEGIN INIT INFO
# Provides: Fess
# Required-Start: $network $named
# Required-Stop: $network $named
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: This service manages the fess daemon

            return this.readErrorResponse(buffer, bufferIndex);
        }
        if (structureSize != 17) {
            throw new SMBProtocolDecodingException("Expected structureSize = 17");
        }

        final short dataOffset = buffer[bufferIndex + 2];
        bufferIndex += 4;
        this.dataLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.dataRemaining = SMBUtil.readInt4(buffer, bufferIndex);

    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {
    TestHasher hasher = new TestHasher();
    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }

  public ClassSanityTester() {
    // TODO(benyu): bake these into ArbitraryInstances.
    setDefault(byte.class, (byte) 1);
    setDefault(Byte.class, (byte) 1);
    setDefault(short.class, (short) 1);
    setDefault(Short.class, (short) 1);
    setDefault(int.class, 1);
    setDefault(Integer.class, 1);
    setDefault(long.class, 1L);
    setDefault(Long.class, 1L);
    setDefault(float.class, 1F);

      byte[] msg = new byte[i];
      for (int j = 0; j < i; ++j) {
        msg[j] = (byte) j;
      }
      assertSip(msg, EXPECTED[i]);
    }
  }

  // This test data comes from "SipHash: a fast short-input PRF", "Appendix A: Test values".
  // It can be downloaded here: https://131002.net/siphash/siphash.pdf
  public void test15ByteStringFromSipHashPaper() {
    byte[] message =
        new byte[] {

///

In HTTP, you send a numeric status code of 3 digits as part of the response.

These status codes have a name associated to recognize them, but the important part is the number.

In short:

* `100 - 199` are for "Information". You rarely use them directly.  Responses with these status codes cannot have a body.
* **`200 - 299`** are for "Successful" responses. These are the ones you would use the most.

        assertFalse(registration.isExpired(60000));

        // Wait a bit to ensure some time has passed
        Thread.sleep(50);
        // Should be expired with very short timeout (shorter than sleep time)
        assertTrue(registration.isExpired(10));
    }

    @Test
    void testStateTransitions() {
        assertEquals(WitnessRegistrationState.REGISTERING, registration.getState());