package utils

import (
	"testing"
)

func TestSourceDir(t *testing.T) {
	cases := []struct {
		file string
		want string
	}{
		{
			file: `C:/Users/name/go/pkg/mod/gorm.io/gorm@v1.2.3/utils/utils.go`,
			want: `C:/Users/name/go/pkg/mod/gorm.io/`,
		},
		{
			file: `C:/go/work/proj/gorm/utils/utils.go`,
			want: `C:/go/work/proj/gorm/`,
		},
		{
			file: `C:/go/work/proj/gorm_alias/utils/utils.go`,

        for (final char element : content) {
            switch (element) {
            case '<':
                buf.append("&lt;");
                break;
            case '>':
                buf.append("&gt;");
                break;
            case '&':
                buf.append("&amp;");
                break;
            case '"':
                buf.append("&quot;");
                break;
            default:

        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return batchLimits[0];
        case SMB_COM_CREATE_DIRECTORY:
            return batchLimits[2];
        case SMB_COM_DELETE:
            return batchLimits[3];
        case SMB_COM_DELETE_DIRECTORY:
            return batchLimits[4];
        case SMB_COM_OPEN_ANDX:
            return batchLimits[5];

		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "NEndpoints":
			z.NEndpoints, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "NEndpoints")
				return
			}
		case "CmdLines":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "CmdLines")
				return

			return
		}
		switch msgp.UnsafeString(field) {
		case "startTs":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "stopTs":
			z.EndTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "EndTime")
				return
			}
		case "status":
			{
				var zb0002 uint8
				zb0002, err = dc.ReadUint8()

            dependency.

            The term "scope" comes from the OAuth2 specification, it seems to be
            intentionally vague and interpretable. It normally refers to permissions,
            in cases to roles.

            These scopes are integrated with OpenAPI (and the API docs at `/docs`).
            So they are visible in the OpenAPI specification.
            )
            """
        ),

    switch (unit) {
      case NANOSECONDS:
        return "ns";
      case MICROSECONDS:
        return "\u03bcs"; // μs
      case MILLISECONDS:
        return "ms";
      case SECONDS:
        return "s";
      case MINUTES:
        return "min";
      case HOURS:
        return "h";
      case DAYS:
        return "d";
    }
    throw new AssertionError();

second_user_data = {
    "id": 4,
    "name": "Mary",
    "joined": "2018-11-30",
}

my_second_user: User = User(**second_user_data)
```

/// info | Informação

`**second_user_data` quer dizer:

Passe as chaves e valores do dicionário `second_user_data` diretamente como argumentos chave-valor, equivalente a: `User(id=4, name="Mary", joined="2018-11-30")`

///

### Suporte de editores { #editor-support }

				if resCh != nil {
					resErr = nil
					select {
					case resCh <- results:
					case <-ctx.Done():
					}
					resCh = nil
					returned = true
				}
				continue
			}
			results.o = append(results.o, entry)
		}
		if resCh != nil {
			resErr = io.EOF
			select {
			case <-ctx.Done():
				// Nobody wants it.
			case resCh <- results:
			}
		}
	}()

		}
		var id64 int64
		switch k {
		case paxPath:
			hdr.Name = v
		case paxLinkpath:
			hdr.Linkname = v
		case paxUname:
			hdr.Uname = v
		case paxGname:
			hdr.Gname = v
		case paxUid:
			id64, err = strconv.ParseInt(v, 10, 64)
			hdr.Uid = int(id64) // Integer overflow possible
		case paxGid:
			id64, err = strconv.ParseInt(v, 10, 64)