github.com/gopacket/gopacket@v1.1.0/layers/asf_presencepong_test.go (about)

     1  // Copyright 2019 The GoPacket Authors. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style license that can be found
     4  // in the LICENSE file in the root of the source tree.
     5  
     6  package layers
     7  
     8  import (
     9  	"bytes"
    10  	"encoding/hex"
    11  	"testing"
    12  
    13  	"github.com/gopacket/gopacket"
    14  )
    15  
    16  func TestASFPresencePongDecodeFromBytes(t *testing.T) {
    17  	b, err := hex.DecodeString("000011be000000008100000000000000")
    18  	if err != nil {
    19  		t.Fatalf("Failed to decode ASF Presence Pong message")
    20  	}
    21  
    22  	pp := &ASFPresencePong{}
    23  	if err := pp.DecodeFromBytes(b, gopacket.NilDecodeFeedback); err != nil {
    24  		t.Fatalf("Unexpected error: %v", err)
    25  	}
    26  	if !bytes.Equal(pp.BaseLayer.Payload, []byte{}) {
    27  		t.Errorf("payload is %v, want %v", pp.BaseLayer.Payload, b)
    28  	}
    29  	if !bytes.Equal(pp.BaseLayer.Contents, b) {
    30  		t.Errorf("contents is %v, want %v", pp.BaseLayer.Contents, b)
    31  	}
    32  	if pp.Enterprise != ASFRMCPEnterprise {
    33  		t.Errorf("want enterprise %v, got %v", ASFRMCPEnterprise, pp.Enterprise)
    34  	}
    35  	if !bytes.Equal(pp.OEM[:], make([]byte, 4)) {
    36  		t.Errorf("want null OEM, got %v", pp.OEM[:])
    37  	}
    38  	if !pp.IPMI {
    39  		t.Errorf("want IPMI, got false")
    40  	}
    41  	if !pp.ASFv1 {
    42  		t.Errorf("want ASFv1, got false")
    43  	}
    44  	if pp.SecurityExtensions {
    45  		t.Errorf("do not want security extensions, got true")
    46  	}
    47  	if pp.DASH {
    48  		t.Errorf("do not want DASH, got true")
    49  	}
    50  }
    51  
    52  func TestASFPresencePongSupportsDCMI(t *testing.T) {
    53  	table := []struct {
    54  		layer *ASFPresencePong
    55  		want  bool
    56  	}{
    57  		{
    58  			&ASFPresencePong{
    59  				Enterprise: ASFRMCPEnterprise,
    60  				IPMI:       true,
    61  				ASFv1:      true,
    62  			},
    63  			false,
    64  		},
    65  		{
    66  			&ASFPresencePong{
    67  				Enterprise: ASFDCMIEnterprise,
    68  				IPMI:       false,
    69  				ASFv1:      true,
    70  			},
    71  			false,
    72  		},
    73  		{
    74  			&ASFPresencePong{
    75  				Enterprise: ASFDCMIEnterprise,
    76  				IPMI:       true,
    77  				ASFv1:      false,
    78  			},
    79  			false,
    80  		},
    81  		{
    82  			&ASFPresencePong{
    83  				Enterprise: ASFDCMIEnterprise,
    84  				IPMI:       true,
    85  				ASFv1:      true,
    86  			},
    87  			true,
    88  		},
    89  	}
    90  	for _, test := range table {
    91  		got := test.layer.SupportsDCMI()
    92  		if got != test.want {
    93  			t.Errorf("%v SupportsDCMI() = %v, want %v", test.layer, got, test.want)
    94  		}
    95  	}
    96  }
    97  
    98  func serializeASFPresencePong(pp *ASFPresencePong) ([]byte, error) {
    99  	sb := gopacket.NewSerializeBuffer()
   100  	err := pp.SerializeTo(sb, gopacket.SerializeOptions{})
   101  	return sb.Bytes(), err
   102  }
   103  
   104  func TestASFPresencePongSerializeTo(t *testing.T) {
   105  	table := []struct {
   106  		layer *ASFPresencePong
   107  		want  []byte
   108  	}{
   109  		{
   110  			&ASFPresencePong{
   111  				Enterprise: ASFRMCPEnterprise,
   112  				IPMI:       true,
   113  				ASFv1:      true,
   114  			},
   115  			[]byte{0, 0, 0x11, 0xbe, 0, 0, 0, 0, 0x81, 0, 0, 0, 0, 0, 0, 0},
   116  		},
   117  		{
   118  			&ASFPresencePong{
   119  				Enterprise:         1234,
   120  				OEM:                [4]byte{1, 2, 3, 4},
   121  				ASFv1:              true,
   122  				SecurityExtensions: true,
   123  				DASH:               true,
   124  			},
   125  			[]byte{0, 0, 0x4, 0xd2, 1, 2, 3, 4, 0x01, 0xa0, 0, 0, 0, 0, 0, 0},
   126  		},
   127  	}
   128  	for _, test := range table {
   129  		b, err := serializeASFPresencePong(test.layer)
   130  		switch {
   131  		case err != nil && test.want != nil:
   132  			t.Errorf("serialize %v failed with %v, wanted %v", test.layer,
   133  				err, test.want)
   134  		case err == nil && !bytes.Equal(b, test.want):
   135  			t.Errorf("serialize %v = %v, want %v", test.layer, b, test.want)
   136  		}
   137  	}
   138  }