@Test
    @DisplayName("writeWireFormat should handle large lengths correctly")
    void testWriteWireFormatLargeLength() {
        packet.type = SessionServicePacket.SESSION_MESSAGE;
        packet.trailerLength = 0x10000; // Length requiring extended bit

        byte[] dst = new byte[100];
        packet.writeWireFormat(dst, 0);

        assertEquals((byte) 0x01, dst[1]); // Extended length bit should be set
    }

    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');

    assertThat(cookie.matches("http://[::1]/".toHttpUrl())).isTrue()
  }

  @Test fun domainMatchesIpv6AddressWithCompression() {
    val cookie = parse("http://[0001:0000::]/".toHttpUrl(), "a=b; domain=0001:0000::")
    assertThat(cookie!!.domain).isEqualTo("1::")
    assertThat(cookie.matches("http://[1::]/".toHttpUrl())).isTrue()
  }

  @Test fun domainMatchesIpv6AddressWithIpv4Suffix() {

	nullTime := sql.NullTime{}
	err := nullTime.Scan(v)
	t.Time = nullTime.Time
	return err
}

func (t EmptyTime) Value() (driver.Value, error) {
	return time.Now() /* pass tests, mysql 8 doesn't support 0000-00-00 by default */, nil
}

type NullString struct {
	sql.NullString
}

type Point struct {
	X, Y int
}

func (point Point) GormDataType() string {
	return "geo"
}

            val low = (if (i + 1 < limit) this[i + 1] else '\u0000')
            if (c.isLowSurrogate() || !low.isLowSurrogate()) {
              '?'.code
            } else {
              i++
              0x010000 + (c.code and 0x03ff shl 10 or (low.code and 0x03ff))
            }
          }

          else -> c.code
        }
      i++
    }
    return result
  }

                                            <la:option value="100">100</la:option>
                                            <la:option value="200">500</la:option>
                                            <la:option value="1000">1000</la:option>
                                        </la:select>
                                    </div>
                                </div>
                                <div class="form-group row">

    }

    @Test
    @DisplayName("Test buffer configuration getters")
    void testBufferConfigurationGetters() {
        assertEquals(0xFFFF - 512, config.getTransactionBufferSize());
        assertEquals(0x10000, config.getMaximumBufferSize());
        assertEquals(16, config.getBufferCacheSize());
        assertEquals(200, config.getListCount());
        assertEquals(65435, config.getListSize());

        assertEquals(0x8000, Smb2CreateRequest.FILE_NO_COMPRESSION);
        assertEquals(0x10000, Smb2CreateRequest.FILE_OPEN_REQUIRING_OPLOCK);
        assertEquals(0x20000, Smb2CreateRequest.FILE_DISALLOW_EXCLUSIVE);
        assertEquals(0x100000, Smb2CreateRequest.FILE_RESERVE_OPFILTER);
        assertEquals(0x200000, Smb2CreateRequest.FILE_OPEN_REPARSE_POINT);

      .isEqualTo("::1")
  }

  @Test
  fun hostIpv6AddressTrailingCompression() {
    assertThat(parse("http://[0001:0000::]").host).isEqualTo("1::")
    assertThat(parse("http://[0001::0000]").host).isEqualTo("1::")
    assertThat(parse("http://[0001::]").host).isEqualTo("1::")
    assertThat(parse("http://[1::]").host).isEqualTo("1::")
  }

  @Test

    assertThat((double) list.get(1)).isEqualTo(1.0);
  }

  // This test stems from a real bug found by andrewk
  public void testAsList_subList_toArray_roundTrip() {
    double[] array = {0.0, 1.0, 2.0, 3.0};
    List<Double> list = Doubles.asList(array);
    assertThat(Doubles.toArray(list.subList(1, 3))).isEqualTo(new double[] {1.0, 2.0});
    assertThat(Doubles.toArray(list.subList(2, 2))).isEmpty();
  }