// license that can be found in the LICENSE file.

// Test that the error message for an unrepresentable typedef in a
// union appears on the right line. This test is only run if the size
// of long double is larger than 64.

package main

/*
typedef long double             Float128;

typedef struct SV {
    union {
        Float128         float128;
    } value;
} SV;
*/
import "C"

type ts struct {
	tv *C.SV // ERROR HERE

   * #create(Funnel, int, double)}, or smaller. If it is significantly higher, it is usually the
   * case that too many elements (more than expected) have been put in the {@code BloomFilter},
   * degenerating it.
   *
   * @since 14.0 (since 11.0 as expectedFalsePositiveProbability())
   */
  public double expectedFpp() {
    return Math.pow((double) bits.bitCount() / bitSize(), numHashFunctions);
  }

        types             | closed
        [Integer]         | typeHierarchyForInteger
        [Integer, Double] | typeHierarchyForInteger + typeHierarchyForDouble
        [Object]          | []
        [GroovyObject]    | []
    }

    static def getTypeHierarchyForDouble() {
        return maybeWithJava12ConstantTypes([Double, Number, Comparable, Serializable])
    }

    static def getTypeHierarchyForInteger() {

    }

    /**
     * {@literal double}配列の末尾に{@literal double}の値を追加した配列を返します。
     *
     * @param array
     *            配列。{@literal null}であってはいけません
     * @param value
     *            値
     * @return 値が追加された結果の配列
     */
    public static double[] add(final double[] array, final double value) {
        assertArgumentNotNull("array", array);

                @Internal
                final Property<Boolean> flag
                @Internal
                final Property<String> message
                @Internal
                final Property<Double> number
                @Internal
                final ListProperty<Integer> list
                @Internal
                final SetProperty<Integer> set
                @Internal

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

/*
long double x = 0;
*/
import "C"

func main() {
	_ = C.x // ERROR HERE
	_ = C.x

    public void setAvailable_PercentileRanks(double[] values) {
        setAvailable_PercentileRanks(values, null);
    }

    public void setAvailable_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setAvailable_PercentileRanks("available", values, opLambda);
    }

    public void setAvailable_PercentileRanks(String name, double[] values,

            return Short.class;
        } else if (type == Byte.TYPE) {
            return Byte.class;
        } else if (type == Float.TYPE) {
            return Float.class;
        } else if (type == Double.TYPE) {
            return Double.class;
        }
        throw new IllegalArgumentException(String.format("Don't know the wrapper type for primitive type %s.", type));
    }

    /**

      writeChar(s.charAt(i));
    }
  }

  /**
   * Writes a {@code double} as specified by {@link DataOutputStream#writeDouble(double)}, except
   * using little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeDouble(double v) throws IOException {
    writeLong(Double.doubleToLongBits(v));
  }

  /**

    // seem to be a worthwhile tradeoff in a browser.
    return matcher;
  }

  static String formatCompact4Digits(double value) {
    return toPrecision(value, 4);
  }

  @JsMethod(name = "Number.prototype.toPrecision.call", namespace = JsPackage.GLOBAL)
  private static native String toPrecision(double value, int precision);

  @JsMethod
  static native boolean stringIsNullOrEmpty(@Nullable String string) /*-{