}

    TestFile file(String name) {
        baseDir.file(name).createFile()
    }

    TestFile link(String name, String target) {
        baseDir.file(name).createLink(target)
    }

    def setMode(int mode) {
        baseDir.mode = mode
    }

    def methodMissing(String name, Object args) {
        if (args.length == 1 && args[0] instanceof Closure) {
            baseDir.file(name).create(args[0])

			// sample operands above require 2 bits to represent mantissa
			// set binary precision to 2 to round them to integer values
			f := new(big.Float).SetPrec(2).SetMode(mode).SetFloat64(f64)
			fmt.Printf("  %*g", len(mode.String()), f)
		}
		fmt.Println()
	}

	// Output:
	//    x  ToNearestEven  ToNearestAway  ToZero  AwayFromZero  ToNegativeInf  ToPositiveInf

     *            the fid to set
     */
    public void setFid ( int fid ) {
        this.fid = fid;
    }


    /**
     * @param mode
     *            the mode to set
     */
    public final void setMode ( int mode ) {
        this.mode = mode;
    }


    /**
     * @param offset
     *            the offset to set
     */
    public final void setOffset ( long offset ) {
        this.offset = offset;

		cmd.Usage()
	}

	mode := args[0]
	if mode != "local" && mode != "off" && mode != "on" {
		cmd.Usage()
	}
	if old := telemetry.Mode(); old == mode {
		return
	}

	if err := telemetry.SetMode(mode); err != nil {
		base.Fatalf("go: failed to set the telemetry mode to %s: %v", mode, err)
	}
	if mode == "on" {
		fmt.Fprintln(os.Stderr, telemetryOnMessage())
	}
}

func telemetryOnMessage() string {

	files := a.Files[:0]
	for _, f := range a.Files {
		if keep(f.Name) {
			files = append(files, f)
		}
	}
	a.Files = files
}

// SetMode changes the mode of every file in the archive
// to be mode(name, m), where m is the file's current mode.
func (a *Archive) SetMode(mode func(name string, m fs.FileMode) fs.FileMode) {
	for i := range a.Files {
		a.Files[i].Mode = mode(a.Files[i].Name, a.Files[i].Mode)
	}
}

     *
     * @param mode the Unix permissions, e.g. {@code 0644}.
     *
     * @deprecated Use {@link #permissions(Action)} instead. This method is scheduled for removal in Gradle 9.0.
     */
    @Deprecated
    void setMode(int mode);

    /**
     * Configuration action for specifying file and directory access permissions.
     * For details see {@link ConfigurableFilePermissions}.
     *
     * @since 8.3
     */

        @Override
        public void setRelativePath(RelativePath path) {
            throw new UnsupportedOperationException();
        }

        @Override
        @Deprecated
        public void setMode(int mode) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void permissions(Action<? super ConfigurableFilePermissions> configureAction) {

	if mode == ToNearestAway {
		panic("not yet implemented")
	}
	if mode == ToNearestEven && rbit == 1 && (sbit == 1 || sbit == 0 && bit0 != 0) || mode == AwayFromZero {
		// round away from zero
		f.SetMode(ToZero).SetPrec(prec)
		f.Add(f, Bits{int(r) + 1}.Float())
	}
	return f
}

// Float returns the *Float z of the smallest possible precision such that

// ParseFloat is like f.Parse(s, base) with f set to the given precision
// and rounding mode.
func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error) {
	return new(Float).SetPrec(prec).SetMode(mode).Parse(s, base)
}

var _ fmt.Scanner = (*Float)(nil) // *Float must implement fmt.Scanner

// Scan is a support routine for [fmt.Scanner]; it sets z to the value of

    stat.getExpression().visit(this);
    stat.setCode(replace(stat.getCode()));
  }

  @Override
  public void visitSynchronizedStatement(SynchronizedStatement stat) {
    stat.getExpression().visit(this);
    stat.setCode(replace(stat.getCode()));
  }

  @Override
  public void visitCatchStatement(CatchStatement stat) {
    stat.setCode(replace(stat.getCode()));
  }

  @Override