github.com/mvdan/u-root-coreutils@v0.0.0-20230122170626-c2eef2898555/pkg/smbios/entry_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  package smbios
     5  
     6  import "testing"
     7  
     8  var (
     9  	validEntry32 = Entry32{
    10  		Anchor:             [4]byte{95, 83, 77, 95},
    11  		Checksum:           0x73,
    12  		Length:             0x1F,
    13  		SMBIOSMajorVersion: 0x01,
    14  		SMBIOSMinorVersion: 0x01,
    15  		StructMaxSize:      0x000E,
    16  		Revision:           0x00,
    17  		Reserved:           [5]byte{0x00, 0x00, 0x00, 0x00, 0x00},
    18  		IntAnchor:          [5]byte{95, 68, 77, 73, 95},
    19  		IntChecksum:        0x68,
    20  		StructTableLength:  0x0000,
    21  		StructTableAddr:    0x00000000,
    22  		NumberOfStructs:    0x0000,
    23  		BCDRevision:        0x00,
    24  	}
    25  )
    26  
    27  func TestEntry32Marshall(t *testing.T) {
    28  	for _, tt := range []struct {
    29  		name  string
    30  		entry Entry32
    31  	}{
    32  		{
    33  			name:  "Test valid Entry32",
    34  			entry: validEntry32,
    35  		},
    36  	} {
    37  		t.Run(tt.name, func(t *testing.T) {
    38  			_, err := tt.entry.MarshalBinary()
    39  			if err != nil {
    40  				t.Errorf("MarshalBinary(): %v", err)
    41  			}
    42  		})
    43  	}
    44  }
    45  
    46  var validEntry32Bytes = []byte{95, 83, 77, 95, 115, 31, 1, 1, 14, 0, 0, 0, 0, 0, 0, 0, 95, 68, 77, 73, 95, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    47  
    48  func TestEntry32Unmarshall(t *testing.T) {
    49  	for _, tt := range []struct {
    50  		name string
    51  		data []byte
    52  	}{
    53  		{
    54  			name: "Test valid data unmarshalling",
    55  			data: validEntry32Bytes,
    56  		},
    57  	} {
    58  		t.Run(tt.name, func(t *testing.T) {
    59  			var e Entry32
    60  			if err := e.UnmarshalBinary(tt.data); err != nil {
    61  				t.Errorf("UnmarshalBinary(): %v", err)
    62  			}
    63  		})
    64  	}
    65  }
    66  
    67  var (
    68  	validEntry64 = Entry64{
    69  		Anchor:             [5]byte{95, 83, 77, 51, 95},
    70  		Checksum:           0x5F,
    71  		Length:             0x18,
    72  		SMBIOSMajorVersion: 0x02,
    73  		SMBIOSMinorVersion: 0x01,
    74  		SMBIOSDocRev:       0x01,
    75  		Revision:           0x00,
    76  		Reserved:           0x00,
    77  		StructMaxSize:      0xFFFFFFFF,
    78  		StructTableAddr:    0xFFFFFFFFFFFFFFFF,
    79  	}
    80  )
    81  
    82  func TestEntry64Marshall(t *testing.T) {
    83  	for _, tt := range []struct {
    84  		name  string
    85  		entry Entry64
    86  	}{
    87  		{
    88  			name:  "Test valid Entry64",
    89  			entry: validEntry64,
    90  		},
    91  	} {
    92  		t.Run(tt.name, func(t *testing.T) {
    93  			t.Log(tt.entry)
    94  			data, err := tt.entry.MarshalBinary()
    95  			if err != nil {
    96  				t.Errorf("MarshalBinary(): %v", err)
    97  			}
    98  			t.Log(data)
    99  		})
   100  	}
   101  }
   102  
   103  var validEntry64Bytes = []byte{95, 83, 77, 51, 95, 95, 24, 2, 1, 1, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
   104  
   105  func TestEntry64Unmarshall(t *testing.T) {
   106  	for _, tt := range []struct {
   107  		name string
   108  		data []byte
   109  	}{
   110  		{
   111  			name: "Test valid data unmarshalling",
   112  			data: validEntry64Bytes,
   113  		},
   114  	} {
   115  		t.Run(tt.name, func(t *testing.T) {
   116  			var e Entry64
   117  			if err := e.UnmarshalBinary(tt.data); err != nil {
   118  				t.Errorf("UnmarshalBinary(): %v", err)
   119  			}
   120  		})
   121  	}
   122  }
   123  
   124  func TestParseEntry(t *testing.T) {
   125  	for _, tt := range []struct {
   126  		name string
   127  		data []byte
   128  	}{
   129  		{
   130  			name: "Test valid data32 unmarshalling",
   131  			data: validEntry32Bytes,
   132  		},
   133  		{
   134  			name: "Test valid data64 unmarshalling",
   135  			data: validEntry64Bytes,
   136  		},
   137  	} {
   138  		t.Run(tt.name, func(t *testing.T) {
   139  			_, _, err := ParseEntry(tt.data)
   140  			if err != nil {
   141  				t.Errorf("ParseEntry(): %v", err)
   142  			}
   143  		})
   144  	}
   145  }