@Param private ComparatorType comparator;

  // TODO(kevinb): add 1000000 back when we have the ability to throw
  // NotApplicableException in the expensive comparator case.
  @Param({"100", "10000"})
  private int size;

  @Param private HeapType heap;

  private Queue<Integer> queue;

  private final Random random = new Random();

  @BeforeExperiment
  void setUp() {

  @Param private ComparatorType comparator;

  // TODO(kevinb): add 1000000 back when we have the ability to throw
  // NotApplicableException in the expensive comparator case.
  @Param({"100", "10000"})
  private int size;

  @Param private HeapType heap;

  private Queue<Integer> queue;

  private final Random random = new Random();

  @BeforeExperiment
  void setUp() {

      var hostname = inetAddress.hostName
      if (inetAddress is Inet6Address && hostname.contains(':')) {
        // hostname is likely some form representing the IPv6 bytes
        // 2001:0db8:85a3:0000:0000:8a2e:0370:7334
        // 2001:db8:85a3::8a2e:370:7334
        // ::1
        hostname = "[$hostname]"
      }

      val localPort = socket.localPort

            assertEquals("2001:db8::1", method.invoke(null, "2001:0db8:0000:0000:0000:0000:0000:0001"));
            assertEquals("fe80::1", method.invoke(null, "fe80:0000:0000:0000:0000:0000:0000:0001"));

            // Leading zeros removed and consecutive zeros compressed
            assertEquals("2001:db8::1", method.invoke(null, "2001:0db8:0:0:0:0:0:1"));

                                            <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">

            return "[" + address + "]";
        }
        return address;
    }

    /**
     * Compresses an IPv6 address string to its canonical compressed form.
     * For example, "0:0:0:0:0:0:0:1" becomes "::1"
     *
     * @param ipv6Address the IPv6 address string to compress
     * @return the compressed IPv6 address string
     */
    protected static String compressIPv6(final String ipv6Address) {

            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
  }

	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"
}

	for i, elt := range e.Elements {
		v, err := elt.evalNode(r, tableAlias)
		if err != nil {
			return nil, err
		}
		res[i] = *v
	}
	return FromArray(res), nil
}

const floatCmpTolerance = 0.000001

func (e *In) evalInNode(r Record, lhs *Value, tableAlias string) (*Value, error) {
	// Compare two values in terms of in-ness.
	var cmp func(a, b Value) bool
	cmp = func(a, b Value) bool {
		// Convert if needed.

                throw IOException("Invalid dynamic table size update $maxDynamicTableByteCount")
              }
              adjustDynamicTableByteCount()
            }

            b == 0x10 || b == 0 -> {
              // 000?0000 - Ignore never indexed bit.
              readLiteralHeaderWithoutIndexingNewName()
            }

            else -> {
              // 000?NNNN - Ignore never indexed bit.