| // Copyright 2014 Google Inc. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package profile |
| |
| import ( |
| "bytes" |
| "fmt" |
| "reflect" |
| "strconv" |
| "strings" |
| "testing" |
| ) |
| |
| func TestLegacyProfileType(t *testing.T) { |
| type testcase struct { |
| sampleTypes []string |
| typeSet [][]string |
| want bool |
| setName string |
| } |
| |
| heap := heapzSampleTypes |
| cont := contentionzSampleTypes |
| testcases := []testcase{ |
| // True cases |
| {[]string{"allocations", "size"}, heap, true, "heapzSampleTypes"}, |
| {[]string{"objects", "space"}, heap, true, "heapzSampleTypes"}, |
| {[]string{"inuse_objects", "inuse_space"}, heap, true, "heapzSampleTypes"}, |
| {[]string{"alloc_objects", "alloc_space"}, heap, true, "heapzSampleTypes"}, |
| {[]string{"alloc_objects", "alloc_space", "inuse_objects", "inuse_space"}, heap, true, "heapzSampleTypes"}, |
| {[]string{"contentions", "delay"}, cont, true, "contentionzSampleTypes"}, |
| // False cases |
| {[]string{"objects"}, heap, false, "heapzSampleTypes"}, |
| {[]string{"objects", "unknown"}, heap, false, "heapzSampleTypes"}, |
| {[]string{"inuse_objects", "inuse_space", "alloc_objects", "alloc_space"}, heap, false, "heapzSampleTypes"}, |
| {[]string{"contentions", "delay"}, heap, false, "heapzSampleTypes"}, |
| {[]string{"samples", "cpu"}, heap, false, "heapzSampleTypes"}, |
| {[]string{"samples", "cpu"}, cont, false, "contentionzSampleTypes"}, |
| } |
| |
| for _, tc := range testcases { |
| p := profileOfType(tc.sampleTypes) |
| if got := isProfileType(p, tc.typeSet); got != tc.want { |
| t.Error("isProfileType({"+strings.Join(tc.sampleTypes, ",")+"},", tc.setName, "), got", got, "want", tc.want) |
| } |
| } |
| } |
| |
| func TestCpuParse(t *testing.T) { |
| // profileString is a legacy encoded profile, represnted by words separated by ":" |
| // Each sample has the form value : N : stack1..stackN |
| // EOF is represented as "0:1:0" |
| profileString := "1:3:100:999:100:" // sample with bogus 999 and duplicate leaf |
| profileString += "1:5:200:999:200:501:502:" // sample with bogus 999 and duplicate leaf |
| profileString += "1:12:300:999:300:601:602:603:604:605:606:607:608:609:" // sample with bogus 999 and duplicate leaf |
| profileString += "0:1:0000" // EOF -- must use 4 bytes for the final zero |
| |
| p, err := cpuProfile([]byte(profileString), 1, parseString) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := checkTestSample(p, []uint64{100}); err != nil { |
| t.Error(err) |
| } |
| if err := checkTestSample(p, []uint64{200, 500, 501}); err != nil { |
| t.Error(err) |
| } |
| if err := checkTestSample(p, []uint64{300, 600, 601, 602, 603, 604, 605, 606, 607, 608}); err != nil { |
| t.Error(err) |
| } |
| } |
| |
| func parseString(b []byte) (uint64, []byte) { |
| slices := bytes.SplitN(b, []byte(":"), 2) |
| var value, remainder []byte |
| if len(slices) > 0 { |
| value = slices[0] |
| } |
| if len(slices) > 1 { |
| remainder = slices[1] |
| } |
| v, _ := strconv.ParseUint(string(value), 10, 64) |
| return v, remainder |
| } |
| |
| func checkTestSample(p *Profile, want []uint64) error { |
| for _, s := range p.Sample { |
| got := []uint64{} |
| for _, l := range s.Location { |
| got = append(got, l.Address) |
| } |
| if reflect.DeepEqual(got, want) { |
| return nil |
| } |
| } |
| return fmt.Errorf("Could not find sample : %v", want) |
| } |
| |
| // profileOfType creates an empty profile with only sample types set, |
| // for testing purposes only. |
| func profileOfType(sampleTypes []string) *Profile { |
| p := new(Profile) |
| p.SampleType = make([]*ValueType, len(sampleTypes)) |
| for i, t := range sampleTypes { |
| p.SampleType[i] = new(ValueType) |
| p.SampleType[i].Type = t |
| } |
| return p |
| } |
| |
| func TestParseMappingEntry(t *testing.T) { |
| for _, test := range []*struct { |
| entry string |
| want *Mapping |
| }{ |
| { |
| entry: "00400000-02e00000 r-xp 00000000 00:00 0", |
| want: &Mapping{ |
| Start: 0x400000, |
| Limit: 0x2e00000, |
| }, |
| }, |
| { |
| entry: "02e00000-02e8a000 r-xp 02a00000 00:00 15953927 /foo/bin", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| Offset: 0x2a00000, |
| File: "/foo/bin", |
| }, |
| }, |
| { |
| entry: "02e00000-02e8a000 r-xp 000000 00:00 15953927 [vdso]", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| File: "[vdso]", |
| }, |
| }, |
| { |
| entry: " 02e00000-02e8a000: /foo/bin (@2a00000)", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| Offset: 0x2a00000, |
| File: "/foo/bin", |
| }, |
| }, |
| { |
| entry: " 02e00000-02e8a000: /foo/bin (deleted)", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| File: "/foo/bin", |
| }, |
| }, |
| { |
| entry: " 02e00000-02e8a000: /foo/bin", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| File: "/foo/bin", |
| }, |
| }, |
| { |
| entry: " 02e00000-02e8a000: [vdso]", |
| want: &Mapping{ |
| Start: 0x2e00000, |
| Limit: 0x2e8a000, |
| File: "[vdso]", |
| }, |
| }, |
| {entry: "0xff6810563000 0xff6810565000 r-xp abc_exe 87c4d547f895cfd6a370e08dc5c5ee7bd4199d5b", |
| want: &Mapping{ |
| Start: 0xff6810563000, |
| Limit: 0xff6810565000, |
| File: "abc_exe", |
| BuildID: "87c4d547f895cfd6a370e08dc5c5ee7bd4199d5b", |
| }, |
| }, |
| {entry: "7f5e5435e000-7f5e5455e000 --xp 00002000 00:00 1531 myprogram", |
| want: &Mapping{ |
| Start: 0x7f5e5435e000, |
| Limit: 0x7f5e5455e000, |
| Offset: 0x2000, |
| File: "myprogram", |
| }, |
| }, |
| {entry: "7f7472710000-7f7472722000 r-xp 00000000 fc:00 790190 /usr/lib/libfantastic-1.2.so", |
| want: &Mapping{ |
| Start: 0x7f7472710000, |
| Limit: 0x7f7472722000, |
| File: "/usr/lib/libfantastic-1.2.so", |
| }, |
| }, |
| {entry: "7f47a542f000-7f47a5447000: /lib/libpthread-2.15.so", |
| want: &Mapping{ |
| Start: 0x7f47a542f000, |
| Limit: 0x7f47a5447000, |
| File: "/lib/libpthread-2.15.so", |
| }, |
| }, |
| {entry: "0x40000-0x80000 /path/to/binary (@FF00) abc123456", |
| want: &Mapping{ |
| Start: 0x40000, |
| Limit: 0x80000, |
| File: "/path/to/binary", |
| Offset: 0xFF00, |
| BuildID: "abc123456", |
| }, |
| }, |
| {entry: "W1220 15:07:15.201776 8272 logger.cc:12033] --- Memory map: ---\n" + |
| "0x40000-0x80000 /path/to/binary (@FF00) abc123456", |
| want: &Mapping{ |
| Start: 0x40000, |
| Limit: 0x80000, |
| File: "/path/to/binary", |
| Offset: 0xFF00, |
| BuildID: "abc123456", |
| }, |
| }, |
| {entry: "W1220 15:07:15.201776 8272 logger.cc:12033] --- Memory map: ---\n" + |
| "W1220 15:07:15.202776 8272 logger.cc:12036] 0x40000-0x80000 /path/to/binary (@FF00) abc123456", |
| want: &Mapping{ |
| Start: 0x40000, |
| Limit: 0x80000, |
| File: "/path/to/binary", |
| Offset: 0xFF00, |
| BuildID: "abc123456", |
| }, |
| }, |
| {entry: "7f5e5435e000-7f5e5455e000 ---p 00002000 00:00 1531 myprogram", |
| want: nil, |
| }, |
| } { |
| got, err := ParseProcMaps(strings.NewReader(test.entry)) |
| if err != nil { |
| t.Errorf("%s: %v", test.entry, err) |
| continue |
| } |
| if test.want == nil { |
| if got, want := len(got), 0; got != want { |
| t.Errorf("%s: got %d mappings, want %d", test.entry, got, want) |
| } |
| continue |
| } |
| if got, want := len(got), 1; got != want { |
| t.Errorf("%s: got %d mappings, want %d", test.entry, got, want) |
| continue |
| } |
| if !reflect.DeepEqual(test.want, got[0]) { |
| t.Errorf("%s want=%v got=%v", test.entry, test.want, got[0]) |
| } |
| } |
| } |
| |
| func TestParseThreadProfileWithInvalidAddress(t *testing.T) { |
| profile := ` |
| --- threadz 1 --- |
| |
| --- Thread 7eff063d9940 (name: main/25376) stack: --- |
| PC: 0x40b688 0x4d5f51 0x40be31 0x473add693e639c6f0 |
| --- Memory map: --- |
| 00400000-00fcb000: /home/rsilvera/cppbench/cppbench_server_main.unstripped |
| ` |
| wantErr := "failed to parse as hex 64-bit number: 0x473add693e639c6f0" |
| if _, gotErr := parseThread([]byte(profile)); !strings.Contains(gotErr.Error(), wantErr) { |
| t.Errorf("parseThread(): got error %q, want error containing %q", gotErr, wantErr) |
| } |
| } |
| |
| func TestParseGoCount(t *testing.T) { |
| for _, test := range []struct { |
| in string |
| typ string |
| }{ |
| { |
| in: `# ignored comment |
| |
| threadcreate profile: total 123 |
| `, |
| typ: "threadcreate", |
| }, |
| { |
| in: ` |
| # ignored comment |
| goroutine profile: total 123456 |
| `, |
| typ: "goroutine", |
| }, |
| { |
| in: ` |
| sub/dir-ect_o.ry profile: total 999 |
| `, |
| typ: "sub/dir-ect_o.ry", |
| }, |
| } { |
| t.Run(test.typ, func(t *testing.T) { |
| p, err := parseGoCount([]byte(test.in)) |
| if err != nil { |
| t.Fatalf("parseGoCount(%q) = %v", test.in, err) |
| } |
| if typ := p.PeriodType.Type; typ != test.typ { |
| t.Fatalf("parseGoCount(%q).PeriodType.Type = %q want %q", test.in, typ, test.typ) |
| } |
| }) |
| } |
| } |
