// REPLREG replicates the register R into 4 uint32s in XR.
#define REPLREG(R, XR) \
	MOVQ R, XR; \
	PSHUFD $0, XR, XR

// REPL replicates the uint32 constant val into 4 uint32s in XR. It smashes DX.
#define REPL(val, XR) \
	MOVL $val, DX; \
	REPLREG(DX, XR)

// SEED copies the off'th uint32 of the seed into the register XR,
// replicating it into all four stripes of the register.
#define SEED(off, reg, XR) \

		fi, err := d.Info()
		if err != nil {
			return err
		}
		fmt.Fprintf(buf, "%s: %v\n", path, fi.Mode())
		return nil
	})
	want := `
.: drwxrwxrwx
a: dr-xr-xr-x
a/b.txt: -rw-rw-rw-
`[1:]
	got := buf.String()
	if want != got {
		t.Errorf("MapFS modes want:\n%s\ngot:\n%s\n", want, got)
	}
}

func TestMapFSFileInfoName(t *testing.T) {
	m := MapFS{

		"- hello.go",
	},
	{
		formatTest{
			name:    "home/gopher",
			size:    0,
			mode:    ModeDir | 0o755,
			modTime: time.Date(1970, time.January, 1, 12, 0, 0, 0, time.UTC),
			isDir:   true,
		},
		"drwxr-xr-x 0 1970-01-01 12:00:00 home/gopher/",
		"d home/gopher/",
	},
	{
		formatTest{
			name:    "big",
			size:    0x7fffffffffffffff,
			mode:    ModeIrregular | 0o644,

     *   </tr>
     *   <tr>
     *     <td>444</td>
     *     <td>r--r--r--</td>
     *     <td>read</td>
     *   </tr>
     *   <tr>
     *     <td>555</td>
     *     <td>r-xr-xr-x</td>
     *     <td>read &amp; execute</td>
     *   </tr>
     *   <tr>
     *     <td>666</td>
     *     <td>rw-rw-rw-</td>
     *     <td>read &amp; write</td>
     *   </tr>
     *   <tr>

----

[.multi-language-sample]
=====
[source, kotlin]
----
drwxr-xr-x  10 gradle-user  staff  320 May 24 18:07 build
-rw-r--r--   1 gradle-user  staff  862 May 24 17:45 build.gradle.kts
drwxr-xr-x   4 gradle-user  staff  128 May 24 17:45 src
----
=====
[.multi-language-sample]
=====
[source, groovy]
----
drwxr-xr-x  10 gradle-user  staff  320 May 24 18:07 build

 * <ul>
 *     <li>FILE: read &amp; write for OWNER, read for GROUP, read for OTHER (0644, rw-r--r--)</li>
 *     <li>DIRECTORY: read, write &amp; execute for OWNER, read &amp; execute for GROUP, read &amp; execute for OTHER (0755, rwxr-xr-x)</li>
 * </ul>
 *
 * @since 8.3
 */
public interface FilePermissions {

    /**
     * Describes what actions the owner of the file can perform on the file/directory.
     * <p>

	for _, xr := range x.R16 {
		lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
		if stride == 1 {
			r = appendRange(r, lo, hi)
			continue
		}
		for c := lo; c <= hi; c += stride {
			r = appendRange(r, c, c)
		}
	}
	for _, xr := range x.R32 {
		lo, hi, stride := rune(xr.Lo), rune(xr.Hi), rune(xr.Stride)
		if stride == 1 {

	// A Montgomery multiplication by a value out of the Montgomery domain
	// takes the result out of Montgomery representation.
	xR := NewNat().set(x).montgomeryRepresentation(m) // xR = x * R mod m
	return x.montgomeryMul(xR, y, m)                  // x = xR * y / R mod m
}

// Exp calculates out = x^e mod m.
//
// The exponent e is represented in big-endian order. The output will be resized

                        }
                    }
               }
            }
        '''.stripIndent()

        when:
        run 'copy'

        then:
        assertDestinationFilePermissions("r-xr-xrw-")
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "permissions block can customize permissions (Kotlin DSL)"() {
        given:
        withSourceFiles("r--------")

    filePermissions {
        user {
            read = true
            execute = true
        }
        other.execute = false
    }
    dirPermissions {
        unix("r-xr-x---")
    }
}
// end::file-permissions[]

tasks.register("test") {
    dependsOn(tasks.withType<Copy>())
    dependsOn(tasks["copyMethod"])
    dependsOn(tasks["copyMethodWithExplicitDependencies"])
}