}

func CutSuffix(s, suffix string) (before string, found bool) {
	if !HasSuffix(s, suffix) {
		return s, false
	}
	return s[:len(s)-len(suffix)], true
}

func TrimPrefix(s, prefix string) string {
	if HasPrefix(s, prefix) {
		return s[len(prefix):]
	}
	return s
}

func TrimSuffix(s, suffix string) string {
	if HasSuffix(s, suffix) {
		return s[:len(s)-len(suffix)]
	}

			op = "FMOVD" + suffix
			args[0] = fmt.Sprintf("F%d", rno&31)
		} else if rno >= uint16(Q0) && rno <= uint16(Q31) {
			op = "FMOVQ" + suffix
			args[0] = fmt.Sprintf("F%d", rno&31)
		} else {
			op = "MOVD" + suffix
		}

	case LDRB:
		op = "MOVBU" + suffix

	case LDRH:
		op = "MOVHU" + suffix

	case LDRSW:
		op = "MOVW" + suffix

	case LDRSB:

        host: foo-svc.default.svc.domain.suffix
        port:
          number: 8000
      headers:
        request:
          add:
            foo: bar
        response:
          add:
            response: header
  - match:
    - uri:
        prefix: /get
    name: default.http.0
    route:
    - destination:
        host: httpbin.default.svc.domain.suffix
        port:
          number: 80

	}
	containerIDWithSuffix := parts[len(parts)-1]
	suffix := fmt.Sprintf(".%s", legacyLogSuffix)
	if !strings.HasSuffix(containerIDWithSuffix, suffix) {
		return "", fmt.Errorf("%q doesn't end with %q", logSymlink, suffix)
	}
	containerIDWithoutSuffix := strings.TrimSuffix(containerIDWithSuffix, suffix)
	// container can be retrieved with container Id as short as 6 characters

            import org.gradle.api.Project

            class HelloWorldPlugin$suffix implements Plugin<Project> {
                void apply(Project project) {
                    project.task('helloWorld$suffix', type: HelloWorld$suffix)
                }
            }
        """

        projectDir.file("src/main/groovy/org/gradle/test/HelloWorld${suffix}.groovy") << """
            package org.gradle.test

	// that the suffix pattern[i+1:] matches, but the byte pattern[i] does
	// not. There are two cases to consider:
	//
	// 1. The matched suffix occurs elsewhere in pattern (with a different
	// byte preceding it that we might possibly match). In this case, we can
	// shift the matching frame to align with the next suffix chunk. For
	// example, the pattern "mississi" has the suffix "issi" next occurring

			continue
		}
		xcom := x.Comment()
		for len(suffix) > 0 && end.Byte <= suffix[len(suffix)-1].Start.Byte {
			if debug {
				fmt.Fprintf(os.Stderr, "ASSIGN SUFFIX %q #%d\n", suffix[len(suffix)-1].Token, suffix[len(suffix)-1].Start.Byte)
			}
			xcom.Suffix = append(xcom.Suffix, suffix[len(suffix)-1])
			suffix = suffix[:len(suffix)-1]
		}
	}

	// We assigned suffix comments in reverse.

)

// NewPattern - create new pattern for prefix/suffix.
func NewPattern(prefix, suffix string) (pattern string) {
	if prefix != "" {
		if !strings.HasSuffix(prefix, "*") {
			prefix += "*"
		}

		pattern = prefix
	}

	if suffix != "" {
		if !strings.HasPrefix(suffix, "*") {
			suffix = "*" + suffix
		}

		pattern += suffix
	}

	pattern = strings.ReplaceAll(pattern, "**", "*")

				},
			},
		},
		{
			name:   "suffix-empty-prefix",
			v:      "*-suffix",
			prefix: "",
			want: &matcher.StringMatcher{
				MatchPattern: &matcher.StringMatcher_Suffix{
					Suffix: "-suffix",
				},
			},
		},
		{
			name:   "suffix",
			v:      "*-suffix",
			prefix: "abc",
			want:   StringMatcherRegex("abc.*-suffix"),
		},
		{
			name:   "exact",
			v:      "-exact",

# argument has .go suffix, is a file and exists
! go get test.go
stderr 'go: test.go: arguments must be package or module paths'

# argument has .go suffix, doesn't exist and has no slashes
! go get test_missing.go
stderr 'arguments must be package or module paths'

# argument has .go suffix, is a file and exists in sub-directory
! go get test/test.go