) == [added("root"), added("root/one"), added("root/two")]
    }

    def "type change missing -> regular file"() {
        expect:
        changes(
            missing("root"),
            regularFile("root", 0x1234)
        ) == [added("root")]
    }

    def "type change regular file -> directory"() {
        expect:
        changes(
            regularFile("root", 0x1234),

apiVersion: release-notes/v2
kind: bug-fix
area: telemetry

issue:
  - 39903

releaseNotes:
  - |

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.file;

import java.io.File;

/**
 * Represents a regular file at a fixed location on the file system. A regular file is a file that is not a directory and is not some special kind of file such as a device.
 * <p>

schemaVersion: 2.2.0
attributes:
  space:
    instanceType: regular
    editor:
      type: Idea
components:
  - name: kotlin-build-env
    container:

  -v D:\data:/data \
  quay.io/minio/minio server /data --console-address ":9001"
```

### Run MinIO Docker as a regular user

Docker provides standardized mechanisms to run docker containers as non-root users.

#### GNU/Linux and macOS (regular user)

On Linux and macOS you can use `--user` to run the container as regular user.

> NOTE: make sure --user has write permission to *${HOME}/data* prior to using `--user`.

```sh

// nextJSCtx returns the context that determines whether a slash after the
// given run of tokens starts a regular expression instead of a division
// operator: / or /=.
//
// This assumes that the token run does not include any string tokens, comment
// tokens, regular expression literal tokens, or division operators.
//
// This fails on some valid but nonsensical JavaScript programs like

     */
    boolean match(String url);

    /**
     * Add an url pattern as a target.
     *
     * @param urlPattern Regular expression that is crawled
     */
    void addInclude(String urlPattern);

    /**
     * Add an url pattern as a non-target.
     *
     * @param urlPattern Regular expression that is not crawled
     */
    void addExclude(String urlPattern);

    /**

            }
        }
    }

    public void addClient(final String regex, final CrawlerClient client) {
        if (StringUtil.isBlank(regex)) {
            throw new CrawlerSystemException("A regular expression is null.");
        }
        if (client == null) {
            throw new CrawlerSystemException("CrawlerClient is null.");
        }
        clientMap.put(Pattern.compile(regex), client);
    }

        def dir2 = provider.get()
        dir2.getAsFile() == projectDir.file("b")

        dir1.getAsFile() == projectDir.file("a")
        dir2.getAsFile() == projectDir.file("b")
    }

    def "can resolve regular file relative to project directory"() {
        def pathProvider = withValues("a", "b")

        expect:
        def file = layout.projectDirectory.file("child")
        file.getAsFile() == projectDir.file("child")

import "p"

type _ = int
type a = struct{ x int }
type b = p.B

type (
	_  = chan<- int
	aa = interface{}
	bb = p.BB
)

// TODO(gri) We may want to put the '=' into a separate column if
// we have mixed (regular and alias) type declarations in a group.
type (
	_   chan<- int
	_   = chan<- int
	aa0 interface{}
	aaa = interface{}
	bb0 p.BB
	bbb = p.BB