case c.Is(ChecksumSHA1):
		return sha1.New()
	case c.Is(ChecksumSHA256):
		return sha256.New()
	}
	return nil
}

// Trailing return whether the checksum is trailing.
func (c ChecksumType) Trailing() bool {
	return c.Is(ChecksumTrailing)
}

// NewChecksumFromData returns a new checksum from specified algorithm and base64 encoded value.

// The byte sequence is followed by a trailing and leading CCC if the values
// for these are not zero.  The value of v determines which ccc are appended
// to the sequences.  For v < firstCCC, there are none, for v >= firstCCC,
// the sequence is followed by a trailing ccc, and for v >= firstLeadingCC
// there is an additional leading ccc. The value of tccc itself is the
// trailing CCC shifted left 2 bits. The two least-significant bits of tccc

				k *= 2
			}

			// The length of the lowest-order zero run is an increment to our maximum.
			j := uint(sys.TrailingZeros64(^x)) // count contiguous trailing ones
			x >>= j & 63                       // remove trailing ones
			j = uint(sys.TrailingZeros64(x))   // count contiguous trailing zeros
			x >>= j & 63                       // remove zeros
			most += j                          // we have a new maximum!

// The byte sequence is followed by a trailing and leading CCC if the values
// for these are not zero.  The value of v determines which ccc are appended
// to the sequences.  For v < firstCCC, there are none, for v >= firstCCC,
// the sequence is followed by a trailing ccc, and for v >= firstLeadingCC
// there is an additional leading ccc. The value of tccc itself is the
// trailing CCC shifted left 2 bits. The two least-significant bits of tccc

			in:   "Line1\nLine2",
			out:  "Line1 Line2",
		},
		{
			desc: "Leading and trailing spaces are stripped (single line)",
			in:   "\t  \nThe text line  \n  \t",
			out:  "The text line",
		},
		{
			desc: "Leading and trailing spaces are stripped (multi line)",
			in:   "\t  \nLine1\nLine2  \n  \t",
			out:  "Line1 Line2",
		},
		{

}

func TestJSONFilterMalformed(t *testing.T) {
	const in = `unexpected text
{"Package":"abc"}
more text
{"Package":"abc"}trailing text
{not json}
no newline`
	const want = `unexpected text
{"Package":"abc:variant"}
more text
{"Package":"abc:variant"}trailing text
{not json}
no newline`
	checkJSONFilter(t, in, want)
}

func TestJSONFilterBoundaries(t *testing.T) {
	const in = `{"Package":"abc"}

      .isEqualTo(28800000L)
    // Ignore trailing junk
    assertThat("Thursday, 01-Jan-1970 00:00:00 PST JUNK".toHttpDateOrNull()!!.time)
      .isEqualTo(28800000L)

    // ANSI C's asctime() format
    // This format ignores the timezone entirely even if it is present and uses GMT.
    assertThat("Fri Jun 6 12:30:30 2014 PST".toHttpDateOrNull()!!.time).isEqualTo(1402057830000L)
    // Ignore trailing junk.

			return true
		}
		return false
	}

	stripDollars := func(b []byte) []byte {
		// Remove trailing $ on lines.
		// They make it easier to see lines with trailing spaces,
		// as well as turning them into lines without trailing spaces,
		// in case editors remove trailing spaces.
		return bytes.ReplaceAll(b, []byte("$\n"), []byte("\n"))
	}
	for _, file := range files {

# module paths with a trailing dot are rejected as invalid import paths
! go mod init example.com/user/repo/v2.
stderr '(?s)^go: malformed module path "example.com/user/repo/v2.": trailing dot in path element$'

! go mod init example.com/user/repo/v2..
stderr '(?s)^go: malformed module path "example.com/user/repo/v2..": trailing dot in path element$'

! go mod init gopkg.in/user/pkg.v.2.

	} else {
		p.printf("\n")
	}
	for i := 0; i < p.margin; i++ {
		p.printf("\t")
	}
}

// trim removes trailing spaces and tabs from the current line.
func (p *printer) trim() {
	// Remove trailing spaces and tabs from line we're about to end.
	b := p.Bytes()
	n := len(b)
	for n > 0 && (b[n-1] == '\t' || b[n-1] == ' ') {
		n--
	}
	p.Truncate(n)
}