if f.Name != ft.Name {
		t.Errorf("name=%q, want %q", f.Name, ft.Name)
	}
	if !ft.Modified.IsZero() && !equalTimeAndZone(f.Modified, ft.Modified) {
		t.Errorf("%s: Modified=%s, want %s", f.Name, f.Modified, ft.Modified)
	}
	if !ft.ModTime.IsZero() && !equalTimeAndZone(f.ModTime(), ft.ModTime) {
		t.Errorf("%s: ModTime=%s, want %s", f.Name, f.ModTime(), ft.ModTime)
	}

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This input was created by taking the ppc64 testcase and modified
// by hand.

#include "../../../../../runtime/textflag.h"

TEXT foo(SB),DUPOK|NOSPLIT,$0
//
// branch
//
//	LBRA rel
//	{
//		outcode(int($1), &nullgen, 0, &$2);
//	}
	BEQ	R1, 2(PC)
label0:

pkg syscall (netbsd-arm64-cgo), const RTF_MASK = 128
pkg syscall (netbsd-arm64-cgo), const RTF_MASK ideal-int
pkg syscall (netbsd-arm64-cgo), const RTF_MODIFIED = 32
pkg syscall (netbsd-arm64-cgo), const RTF_MODIFIED ideal-int
pkg syscall (netbsd-arm64-cgo), const RTF_PROTO1 = 32768
pkg syscall (netbsd-arm64-cgo), const RTF_PROTO1 ideal-int
pkg syscall (netbsd-arm64-cgo), const RTF_PROTO2 = 16384

<code>R27</code> and <code>R28</code> are reserved by the compiler and linker.
<code>R29</code> is the frame pointer.
<code>R30</code> is the link register.
</p>

<p>
Instruction modifiers are appended to the instruction following a period.
The only modifiers are <code>P</code> (postincrement) and <code>W</code>
(preincrement):
<code>MOVW.P</code>, <code>MOVW.W</code>
</p>

<p>
Addressing modes:
</p>

<ul>

			tok = p.nextToken()
			if len(operands) == 0 && len(items) == 0 {
				if p.arch.InFamily(sys.ARM, sys.ARM64, sys.AMD64, sys.I386, sys.RISCV64) && tok == '.' {
					// Suffixes: ARM conditionals, RISCV rounding mode or x86 modifiers.
					tok = p.nextToken()
					str := p.lex.Text()
					if tok != scanner.Ident {
						p.errorf("instruction suffix expected identifier, found %s", str)
					}
					cond = cond + "." + str
					continue

		Name:             "foo.txt",
		UncompressedSize: 987654321,
		Modified:         time.Now().Local(),
		ModifiedTime:     1234,
		ModifiedDate:     5678,
	}
	fi := fh.FileInfo()
	fh2, err := FileInfoHeader(fi)
	if err != nil {
		t.Fatal(err)
	}
	if got, want := fh2.Modified, fh.Modified.UTC(); got != want {
		t.Errorf("Modified: got %s, want %s\n", got, want)
	}

func HasSuffix(s, suffix []byte) bool {
	return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix):], suffix)
}

// Map returns a copy of the byte slice s with all its characters modified
// according to the mapping function. If mapping returns a negative value, the character is
// dropped from the byte slice with no replacement. The characters in s and the
// output are interpreted as UTF-8-encoded code points.

pkg syscall (darwin-386), const RTF_IFSCOPE = 16777216
pkg syscall (darwin-386), const RTF_LLINFO = 1024
pkg syscall (darwin-386), const RTF_LOCAL = 2097152
pkg syscall (darwin-386), const RTF_MODIFIED = 32
pkg syscall (darwin-386), const RTF_MULTICAST = 8388608
pkg syscall (darwin-386), const RTF_PINNED = 1048576
pkg syscall (darwin-386), const RTF_PRCLONING = 65536
pkg syscall (darwin-386), const RTF_PROTO1 = 32768

[<a href="#Go_1.20">Go 1.20</a>]
</p>

<p>
The function <code>StringData</code> returns a pointer to the underlying bytes of the <code>str</code> argument.
For an empty string the return value is unspecified, and may be <code>nil</code>.
Since Go strings are immutable, the bytes returned by <code>StringData</code> must not be modified
[<a href="#Go_1.20">Go 1.20</a>].

pkg syscall (freebsd-386-cgo), const RTF_LLDATA ideal-int
pkg syscall (freebsd-386-cgo), const RTF_LLINFO ideal-int
pkg syscall (freebsd-386-cgo), const RTF_LOCAL ideal-int
pkg syscall (freebsd-386-cgo), const RTF_MODIFIED ideal-int
pkg syscall (freebsd-386-cgo), const RTF_MULTICAST ideal-int
pkg syscall (freebsd-386-cgo), const RTF_PINNED ideal-int
pkg syscall (freebsd-386-cgo), const RTF_PRCLONING ideal-int