rm -rf work
mkdir work
go build -o work/mkzip mkzip.go # build now for correct paths in build errors
cd work
mkdir zoneinfo
curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
tar xzf tzcode$CODE.tar.gz
tar xzf tzdata$DATA.tar.gz

# The PACKRATLIST and PACKRATDATA options are copied from Ubuntu:

	decomBuckets := make([]decomBucketInfo, len(buckets))
	for i := range buckets {
		decomBuckets[i] = decomBucketInfo{
			Name: buckets[i].Name,
		}
	}

	// Buckets data are dispersed in multiple zones/sets, make
	// sure to decommission the necessary metadata.
	decomMetaBuckets := []decomBucketInfo{
		{
			Name:   minioMetaBucket,
			Prefix: minioConfigPrefix,
		},
		{
			Name:   minioMetaBucket,

    @Test
    public void test_isUseTimeZoneHandling() {
        // Verify that time zone handling is disabled
        assertFalse(provider.isUseTimeZoneHandling());
    }

    // Test isAcceptCookieTimeZone() method
    @Test
    public void test_isAcceptCookieTimeZone() {
        // Verify that cookie time zone is not accepted
        assertFalse(provider.isAcceptCookieTimeZone());
    }

		// TODO: function gen_random_uuid() does not exist
		ID        string `gorm:"default:gen_random_uuid()"`
		Name      string
		CreatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE"`
		UpdatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE;default:current_timestamp"`
	}

	if err := DB.Exec("CREATE EXTENSION IF NOT EXISTS pgcrypto;").Error; err != nil {
		t.Errorf("Failed to create extension pgcrypto, got error %v", err)
	}

		return FromInt(int64(t.Minute())), nil
	case timePartSecond:
		return FromInt(int64(t.Second())), nil
	case timePartTimezoneHour:
		_, zoneOffset := t.Zone()
		return FromInt(int64(zoneOffset / 3600)), nil
	case timePartTimezoneMinute:
		_, zoneOffset := t.Zone()
		return FromInt(int64((zoneOffset % 3600) / 60)), nil
	default:
		// This does not happen
		return nil, errNotImplemented
	}
}

     * Verifies that the method returns the correct time zone offset.
     * @throws CIFSException
     */
    @Test
    void testGetServerTimeZoneOffset() throws CIFSException {
        when(smbTreeHandle.getServerTimeZoneOffset()).thenReturn(0L);
        assertEquals(0L, smbTreeHandle.getServerTimeZoneOffset(), "Server time zone offset should be 0");

		go target.Cancel()
	}
}

// UpdateHTTPWebhooks swaps system webhook targets with newly loaded ones from the cfg
func UpdateHTTPWebhooks(ctx context.Context, cfgs map[string]http.Config) (errs []error) {
	return updateHTTPTargets(ctx, cfgs, systemTargets)
}

// UpdateAuditWebhooks swaps audit webhook targets with newly loaded ones from the cfg
func UpdateAuditWebhooks(ctx context.Context, cfgs map[string]http.Config) (errs []error) {

	if len(listener.listeners) == 1 {
		return addr
	}

	if tcpAddr, ok := addr.(*net.TCPAddr); ok {
		return &net.TCPAddr{
			IP:   net.IPv4zero,
			Port: tcpAddr.Port,
			Zone: tcpAddr.Zone,
		}
	}
	panic("unknown address type on listener")
}

// Addrs - returns all address information of TCP listeners.
func (listener *httpListener) Addrs() (addrs []net.Addr) {

    override fun execute(details: CompatibilityCheckDetails<NullawayState>) {
        with(details) {
            when {
                // Nullaway-enabled targets must not depend on nullaway-disabled ones.
                // They can depend on nullaway-undefined, which any external dependency is going to be.
                producerValue == NullawayState.DISABLED && consumerValue == NullawayState.ENABLED -> incompatible()

    extends AbstractFuture<V> {
  /*
   * This server copy of the class is empty. The corresponding GWT copy contains alternative
   * versions of catching() and catchingAsync() with slightly different signatures from the ones
   * found in FluentFuture.java.
   */