github.com/mvdan/u-root-coreutils@v0.0.0-20230122170626-c2eef2898555/pkg/smbios/info64_test.go (about)

     1  // Copyright 2016-2021 the u-root Authors. All rights reserved
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package smbios
     6  
     7  import (
     8  	"io/ioutil"
     9  	"os"
    10  	"path/filepath"
    11  	"reflect"
    12  	"testing"
    13  )
    14  
    15  func Test64ParseInfo(t *testing.T) {
    16  	info, err := setupMockData()
    17  	if err != nil {
    18  		t.Errorf("error parsing info data: %v", err)
    19  	}
    20  	if info.Entry32 != nil {
    21  		t.Errorf("false detection of 32-bit SMBIOS table header")
    22  	}
    23  }
    24  
    25  func Test64ParseInfoHeaderMalformed(t *testing.T) {
    26  	data, err := ioutil.ReadFile("./testdata/smbios_table.bin")
    27  	if err != nil {
    28  		t.Errorf("error reading mockup smbios tables: %v", err)
    29  	}
    30  
    31  	entryData := data[:10]
    32  	data = data[32:]
    33  
    34  	_, err = ParseInfo(entryData, data)
    35  	if err == nil {
    36  		t.Errorf("error parsing info data: %v", err)
    37  	}
    38  }
    39  
    40  func Test64MajorVersion(t *testing.T) {
    41  	info, err := setupMockData()
    42  	if err != nil {
    43  		t.Errorf("error parsing info data: %v", err)
    44  	}
    45  	if info.MajorVersion() != 3 {
    46  		t.Errorf("major version should be 3 - got %d", info.MajorVersion())
    47  	}
    48  }
    49  
    50  func Test64MinorVersion(t *testing.T) {
    51  
    52  	info, err := setupMockData()
    53  	if err != nil {
    54  		t.Errorf("error parsing info data: %v", err)
    55  	}
    56  	if info.MinorVersion() != 1 {
    57  		t.Errorf("minor version should be 1 - got %d", info.MinorVersion())
    58  	}
    59  }
    60  
    61  func Test64DocRev(t *testing.T) {
    62  
    63  	info, err := setupMockData()
    64  	if err != nil {
    65  		t.Errorf("error parsing info data: %v", err)
    66  	}
    67  	if info.DocRev() != 1 {
    68  		t.Errorf("doc revision should be 1 - got %d", info.DocRev())
    69  	}
    70  }
    71  
    72  func Test64GetTablesByType(t *testing.T) {
    73  
    74  	info, err := setupMockData()
    75  	if err != nil {
    76  		t.Errorf("error parsing info data: %v", err)
    77  	}
    78  
    79  	table := info.GetTablesByType(TableTypeBIOSInfo)
    80  	if table == nil {
    81  		t.Errorf("unable to get type")
    82  	}
    83  	if table != nil {
    84  		if table[0].Header.Type != TableTypeBIOSInfo {
    85  			t.Errorf("Wrong type. Got %v but want %v", TableTypeBIOSInfo, table[0].Header.Type)
    86  		}
    87  	}
    88  }
    89  
    90  func setupMockData() (*Info, error) {
    91  	data, err := ioutil.ReadFile("./testdata/smbios_table.bin")
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  
    96  	entryData := data[:32]
    97  	data = data[32:]
    98  
    99  	info, err := ParseInfo(entryData, data)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  
   104  	return info, nil
   105  }
   106  
   107  func FuzzParseInfo(f *testing.F) {
   108  	seeds, err := filepath.Glob("testdata/*.bin")
   109  	if err != nil {
   110  		f.Fatalf("failed to find seed corpora files: %v", err)
   111  	}
   112  
   113  	for _, seed := range seeds {
   114  		seedBytes, err := os.ReadFile(seed)
   115  		if err != nil {
   116  			f.Fatalf("failed read seed corpora from files %v: %v", seed, err)
   117  		}
   118  
   119  		f.Add(seedBytes)
   120  	}
   121  
   122  	f.Fuzz(func(t *testing.T, data []byte) {
   123  
   124  		if len(data) < 64 || len(data) > 4096 {
   125  			return
   126  		}
   127  
   128  		entryData := data[:32]
   129  		data = data[32:]
   130  
   131  		info, err := ParseInfo(entryData, data)
   132  		if err != nil {
   133  			return
   134  		}
   135  
   136  		var entry []byte
   137  		if info.Entry32 != nil {
   138  			entry, err = info.Entry32.MarshalBinary()
   139  		} else if info.Entry64 != nil {
   140  			entry, err = info.Entry64.MarshalBinary()
   141  
   142  		} else {
   143  			t.Fatalf("expected a SMBIOS 32-Bit or 64-Bit entry point but got none")
   144  		}
   145  
   146  		if err != nil {
   147  			t.Fatalf("failed to unmarshal entry data")
   148  		}
   149  
   150  		reparsedInfo, err := ParseInfo(entry, data)
   151  		if err != nil {
   152  			t.Fatalf("failed to reparse the SMBIOS info struct")
   153  		}
   154  		if !reflect.DeepEqual(info, reparsedInfo) {
   155  			t.Errorf("expected: %#v\ngot:%#v", info, reparsedInfo)
   156  		}
   157  	})
   158  }