Properties properties = new Properties()
                properties.JAVA_HOME = String.valueOf(System.getenv('JAVA_HOME'))
                properties.GRADLE_USER_HOME = String.valueOf(gradle.gradleUserHomeDir.absolutePath)
                properties.GRADLE_OPTS = String.valueOf(System.getenv('GRADLE_OPTS'))
                return properties
            }

            void assertEquals(key, expected, actual) {

        then:
        provider
        provider.get() == value

        where:
        type      | value
        Boolean   | true
        Byte      | Byte.valueOf((byte) 0)
        Short     | Short.valueOf((short) 0)
        Integer   | Integer.valueOf(0)
        Long      | 4L
        Float     | 5.5f
        Double    | 6.6d
        Character | '\u1234'
        String    | 'hello'
        File      | TEST_FILE

	}
	return false
}

func AssertEqual(x, y interface{}) bool {
	if reflect.DeepEqual(x, y) {
		return true
	}
	if x == nil || y == nil {
		return false
	}

	xval := reflect.ValueOf(x)
	yval := reflect.ValueOf(y)
	if xval.Kind() == reflect.Ptr && xval.IsNil() ||
		yval.Kind() == reflect.Ptr && yval.IsNil() {
		return false
	}

	if valuer, ok := x.(driver.Valuer); ok {
		x, _ = valuer.Value()
	}

class PrettyCalculatorSpec extends Specification {

    def "knows percentage change"() {
        expect:
        percentChange(Amount.valueOf(current, Duration.SECONDS), Amount.valueOf(previous, Duration.SECONDS)) == percent

        where:
        current  | previous | percent
        1        | 1        | 0
        3        | 1        | 200
        1        | 3        | -66.67

    assertThrows(
        UnsupportedOperationException.class,
        () -> map.put(TypeToken.of(Integer.class), Integer.valueOf(5)));
  }

  public void testPutAllThrows() {
    assertThrows(
        UnsupportedOperationException.class,
        () -> map.putAll(ImmutableMap.of(TypeToken.of(Integer.class), Integer.valueOf(5))));
  }

  public void testEntrySetMutationThrows() {
    map.putInstance(String.class, "test");

        } else {
            int baseExponent = (Long.SIZE - 1 - Long.numberOfLeadingZeros(bytes)) / BASE_LOG2;
            BigDecimal roundedBase = BigDecimal.valueOf(1L << (baseExponent * BASE_LOG2));
            BigDecimal result = BigDecimal.valueOf(bytes).divide(roundedBase, MC).setScale(FRACTIONAL_DIGIT_COUNT, FLOOR).stripTrailingZeros();
            return result.toPlainString() + UNITS.get(baseExponent);
        }
    }

    /**
     * @throws Exception
     */
    public void testToBoolean() throws Exception {
        assertEquals("1", Boolean.TRUE, BooleanConversionUtil.toBoolean(Integer.valueOf(1)));
        assertEquals("2", Boolean.FALSE, BooleanConversionUtil.toBoolean(Integer.valueOf(0)));
        assertEquals("3", Boolean.FALSE, BooleanConversionUtil.toBoolean("0"));
        assertEquals("4", Boolean.TRUE, BooleanConversionUtil.toBoolean("1"));

      is_argmax ? mhlo::ComparisonDirection::GT : mhlo::ComparisonDirection::LT;
  if (is_float) {
    mhlo::OrOp value_or = llvm::dyn_cast_or_null<mhlo::OrOp>(
        value_select.getOperand(0).getDefiningOp());
    if (!value_or) return failure();

    mhlo::CompareOp value_gt = llvm::dyn_cast_or_null<mhlo::CompareOp>(
        value_or.getLhs().getDefiningOp());
    if (!value_gt || value_gt.getComparisonDirection() != compare_direction ||

    } catch (NoSuchFieldException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**
   * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
   * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
   * user input or falling back to a default enum constant. For example, {@code

// yet exported.
package typesinternal

import (
	"go/token"
	"go/types"
	"reflect"
	"unsafe"
)

func SetUsesCgo(conf *types.Config) bool {
	v := reflect.ValueOf(conf).Elem()

	f := v.FieldByName("go115UsesCgo")
	if !f.IsValid() {
		f = v.FieldByName("UsesCgo")
		if !f.IsValid() {
			return false
		}
	}

	addr := unsafe.Pointer(f.UnsafeAddr())