diff options
Diffstat (limited to 'tunnel/winipcfg/types_test.go')
| -rw-r--r-- | tunnel/winipcfg/types_test.go | 1057 |
1 files changed, 1057 insertions, 0 deletions
diff --git a/tunnel/winipcfg/types_test.go b/tunnel/winipcfg/types_test.go new file mode 100644 index 00000000..c7494e8c --- /dev/null +++ b/tunnel/winipcfg/types_test.go @@ -0,0 +1,1057 @@ +/* SPDX-License-Identifier: MIT + * + * Copyright (C) 2019 WireGuard LLC. All Rights Reserved. + */ + +package winipcfg + +import ( + "testing" + "unsafe" +) + +const ( + mibIPInterfaceRowSize = 168 + mibIPInterfaceRowInterfaceLUIDOffset = 8 + mibIPInterfaceRowInterfaceIndexOffset = 16 + mibIPInterfaceRowMaxReassemblySizeOffset = 20 + mibIPInterfaceRowInterfaceIdentifierOffset = 24 + mibIPInterfaceRowMinRouterAdvertisementIntervalOffset = 32 + mibIPInterfaceRowMaxRouterAdvertisementIntervalOffset = 36 + mibIPInterfaceRowAdvertisingEnabledOffset = 40 + mibIPInterfaceRowForwardingEnabledOffset = 41 + mibIPInterfaceRowWeakHostSendOffset = 42 + mibIPInterfaceRowWeakHostReceiveOffset = 43 + mibIPInterfaceRowUseAutomaticMetricOffset = 44 + mibIPInterfaceRowUseNeighborUnreachabilityDetectionOffset = 45 + mibIPInterfaceRowManagedAddressConfigurationSupportedOffset = 46 + mibIPInterfaceRowOtherStatefulConfigurationSupportedOffset = 47 + mibIPInterfaceRowAdvertiseDefaultRouteOffset = 48 + mibIPInterfaceRowRouterDiscoveryBehaviorOffset = 52 + mibIPInterfaceRowDadTransmitsOffset = 56 + mibIPInterfaceRowBaseReachableTimeOffset = 60 + mibIPInterfaceRowRetransmitTimeOffset = 64 + mibIPInterfaceRowPathMTUDiscoveryTimeoutOffset = 68 + mibIPInterfaceRowLinkLocalAddressBehaviorOffset = 72 + mibIPInterfaceRowLinkLocalAddressTimeoutOffset = 76 + mibIPInterfaceRowZoneIndicesOffset = 80 + mibIPInterfaceRowSitePrefixLengthOffset = 144 + mibIPInterfaceRowMetricOffset = 148 + mibIPInterfaceRowNLMTUOffset = 152 + mibIPInterfaceRowConnectedOffset = 156 + mibIPInterfaceRowSupportsWakeUpPatternsOffset = 157 + mibIPInterfaceRowSupportsNeighborDiscoveryOffset = 158 + mibIPInterfaceRowSupportsRouterDiscoveryOffset = 159 + mibIPInterfaceRowReachableTimeOffset = 160 + mibIPInterfaceRowTransmitOffloadOffset = 164 + mibIPInterfaceRowReceiveOffloadOffset = 165 + mibIPInterfaceRowDisableDefaultRoutesOffset = 166 + + mibIPInterfaceTableSize = 176 + mibIPInterfaceTableTableOffset = 8 + + mibIfRow2Size = 1352 + mibIfRow2InterfaceIndexOffset = 8 + mibIfRow2InterfaceGUIDOffset = 12 + mibIfRow2AliasOffset = 28 + mibIfRow2DescriptionOffset = 542 + mibIfRow2PhysicalAddressLengthOffset = 1056 + mibIfRow2PhysicalAddressOffset = 1060 + mibIfRow2PermanentPhysicalAddressOffset = 1092 + mibIfRow2MTUOffset = 1124 + mibIfRow2TypeOffset = 1128 + mibIfRow2TunnelTypeOffset = 1132 + mibIfRow2MediaTypeOffset = 1136 + mibIfRow2PhysicalMediumTypeOffset = 1140 + mibIfRow2AccessTypeOffset = 1144 + mibIfRow2DirectionTypeOffset = 1148 + mibIfRow2InterfaceAndOperStatusFlagsOffset = 1152 + mibIfRow2OperStatusOffset = 1156 + mibIfRow2AdminStatusOffset = 1160 + mibIfRow2MediaConnectStateOffset = 1164 + mibIfRow2NetworkGUIDOffset = 1168 + mibIfRow2ConnectionTypeOffset = 1184 + mibIfRow2TransmitLinkSpeedOffset = 1192 + mibIfRow2ReceiveLinkSpeedOffset = 1200 + mibIfRow2InOctetsOffset = 1208 + mibIfRow2InUcastPktsOffset = 1216 + mibIfRow2InNUcastPktsOffset = 1224 + mibIfRow2InDiscardsOffset = 1232 + mibIfRow2InErrorsOffset = 1240 + mibIfRow2InUnknownProtosOffset = 1248 + mibIfRow2InUcastOctetsOffset = 1256 + mibIfRow2InMulticastOctetsOffset = 1264 + mibIfRow2InBroadcastOctetsOffset = 1272 + mibIfRow2OutOctetsOffset = 1280 + mibIfRow2OutUcastPktsOffset = 1288 + mibIfRow2OutNUcastPktsOffset = 1296 + mibIfRow2OutDiscardsOffset = 1304 + mibIfRow2OutErrorsOffset = 1312 + mibIfRow2OutUcastOctetsOffset = 1320 + mibIfRow2OutMulticastOctetsOffset = 1328 + mibIfRow2OutBroadcastOctetsOffset = 1336 + mibIfRow2OutQLenOffset = 1344 + + mibIfTable2Size = 1360 + mibIfTable2TableOffset = 8 + + rawSockaddrInetSize = 28 + rawSockaddrInetDataOffset = 2 + + mibUnicastIPAddressRowSize = 80 + mibUnicastIPAddressRowInterfaceLUIDOffset = 32 + mibUnicastIPAddressRowInterfaceIndexOffset = 40 + mibUnicastIPAddressRowPrefixOriginOffset = 44 + mibUnicastIPAddressRowSuffixOriginOffset = 48 + mibUnicastIPAddressRowValidLifetimeOffset = 52 + mibUnicastIPAddressRowPreferredLifetimeOffset = 56 + mibUnicastIPAddressRowOnLinkPrefixLengthOffset = 60 + mibUnicastIPAddressRowSkipAsSourceOffset = 61 + mibUnicastIPAddressRowDadStateOffset = 64 + mibUnicastIPAddressRowScopeIDOffset = 68 + mibUnicastIPAddressRowCreationTimeStampOffset = 72 + + mibUnicastIPAddressTableSize = 88 + mibUnicastIPAddressTableTableOffset = 8 + + mibAnycastIPAddressRowSize = 48 + mibAnycastIPAddressRowInterfaceLUIDOffset = 32 + mibAnycastIPAddressRowInterfaceIndexOffset = 40 + mibAnycastIPAddressRowScopeIDOffset = 44 + + mibAnycastIPAddressTableSize = 56 + mibAnycastIPAddressTableTableOffset = 8 + + ipAddressPrefixSize = 32 + ipAddressPrefixPrefixLengthOffset = 28 + + mibIPforwardRow2Size = 104 + mibIPforwardRow2InterfaceIndexOffset = 8 + mibIPforwardRow2DestinationPrefixOffset = 12 + mibIPforwardRow2NextHopOffset = 44 + mibIPforwardRow2SitePrefixLengthOffset = 72 + mibIPforwardRow2ValidLifetimeOffset = 76 + mibIPforwardRow2PreferredLifetimeOffset = 80 + mibIPforwardRow2MetricOffset = 84 + mibIPforwardRow2ProtocolOffset = 88 + mibIPforwardRow2LoopbackOffset = 92 + mibIPforwardRow2AutoconfigureAddressOffset = 93 + mibIPforwardRow2PublishOffset = 94 + mibIPforwardRow2ImmortalOffset = 95 + mibIPforwardRow2AgeOffset = 96 + mibIPforwardRow2OriginOffset = 100 + + mibIPforwardTable2Size = 112 + mibIPforwardTable2TableOffset = 8 +) + +func TestIPAdapterWINSServerAddress(t *testing.T) { + s := IPAdapterWINSServerAddress{} + sp := uintptr(unsafe.Pointer(&s)) + const actualIPAdapterWINSServerAddressSize = unsafe.Sizeof(s) + + if actualIPAdapterWINSServerAddressSize != ipAdapterWINSServerAddressSize { + t.Errorf("Size of IPAdapterWINSServerAddress is %d, although %d is expected.", actualIPAdapterWINSServerAddressSize, ipAdapterWINSServerAddressSize) + } + + offset := uintptr(unsafe.Pointer(&s.Next)) - sp + if offset != ipAdapterWINSServerAddressNextOffset { + t.Errorf("IPAdapterWINSServerAddress.Next offset is %d although %d is expected", offset, ipAdapterWINSServerAddressNextOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Address)) - sp + if offset != ipAdapterWINSServerAddressAddressOffset { + t.Errorf("IPAdapterWINSServerAddress.Address offset is %d although %d is expected", offset, ipAdapterWINSServerAddressAddressOffset) + } +} + +func TestIPAdapterGatewayAddress(t *testing.T) { + s := IPAdapterGatewayAddress{} + sp := uintptr(unsafe.Pointer(&s)) + const actualIPAdapterGatewayAddressSize = unsafe.Sizeof(s) + + if actualIPAdapterGatewayAddressSize != ipAdapterGatewayAddressSize { + t.Errorf("Size of IPAdapterGatewayAddress is %d, although %d is expected.", actualIPAdapterGatewayAddressSize, ipAdapterGatewayAddressSize) + } + + offset := uintptr(unsafe.Pointer(&s.Next)) - sp + if offset != ipAdapterGatewayAddressNextOffset { + t.Errorf("IPAdapterGatewayAddress.Next offset is %d although %d is expected", offset, ipAdapterGatewayAddressNextOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Address)) - sp + if offset != ipAdapterGatewayAddressAddressOffset { + t.Errorf("IPAdapterGatewayAddress.Address offset is %d although %d is expected", offset, ipAdapterGatewayAddressAddressOffset) + } +} + +func TestIPAdapterDNSSuffix(t *testing.T) { + s := IPAdapterDNSSuffix{} + sp := uintptr(unsafe.Pointer(&s)) + const actualIPAdapterDNSSuffixSize = unsafe.Sizeof(s) + + if actualIPAdapterDNSSuffixSize != ipAdapterDNSSuffixSize { + t.Errorf("Size of IPAdapterDNSSuffix is %d, although %d is expected.", actualIPAdapterDNSSuffixSize, ipAdapterDNSSuffixSize) + } + + offset := uintptr(unsafe.Pointer(&s.str)) - sp + if offset != ipAdapterDNSSuffixStringOffset { + t.Errorf("IPAdapterDNSSuffix.str offset is %d although %d is expected", offset, ipAdapterDNSSuffixStringOffset) + } +} + +func TestInAdapterAddresses(t *testing.T) { + s := IPAdapterAddresses{} + sp := uintptr(unsafe.Pointer(&s)) + const actualIn6AddrSize = unsafe.Sizeof(s) + + if actualIn6AddrSize != ipAdapterAddressesSize { + t.Errorf("Size of IPAdapterAddresses is %d, although %d is expected.", actualIn6AddrSize, ipAdapterAddressesSize) + } + + offset := uintptr(unsafe.Pointer(&s.IfIndex)) - sp + if offset != ipAdapterAddressesIfIndexOffset { + t.Errorf("IPAdapterAddresses.IfIndex offset is %d although %d is expected", offset, ipAdapterAddressesIfIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Next)) - sp + if offset != ipAdapterAddressesNextOffset { + t.Errorf("IPAdapterAddresses.Next offset is %d although %d is expected", offset, ipAdapterAddressesNextOffset) + } + + offset = uintptr(unsafe.Pointer(&s.adapterName)) - sp + if offset != ipAdapterAddressesAdapterNameOffset { + t.Errorf("IPAdapterAddresses.adapterName offset is %d although %d is expected", offset, ipAdapterAddressesAdapterNameOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstUnicastAddress)) - sp + if offset != ipAdapterAddressesFirstUnicastAddressOffset { + t.Errorf("IPAdapterAddresses.FirstUnicastAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstUnicastAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstAnycastAddress)) - sp + if offset != ipAdapterAddressesFirstAnycastAddressOffset { + t.Errorf("IPAdapterAddresses.FirstAnycastAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstAnycastAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstMulticastAddress)) - sp + if offset != ipAdapterAddressesFirstMulticastAddressOffset { + t.Errorf("IPAdapterAddresses.FirstMulticastAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstMulticastAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstDNSServerAddress)) - sp + if offset != ipAdapterAddressesFirstDNSServerAddressOffset { + t.Errorf("IPAdapterAddresses.FirstDNSServerAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstDNSServerAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.dnsSuffix)) - sp + if offset != ipAdapterAddressesDNSSuffixOffset { + t.Errorf("IPAdapterAddresses.DNSSuffix offset is %d although %d is expected", offset, ipAdapterAddressesDNSSuffixOffset) + } + + offset = uintptr(unsafe.Pointer(&s.description)) - sp + if offset != ipAdapterAddressesDescriptionOffset { + t.Errorf("IPAdapterAddresses.Description offset is %d although %d is expected", offset, ipAdapterAddressesDescriptionOffset) + } + + offset = uintptr(unsafe.Pointer(&s.friendlyName)) - sp + if offset != ipAdapterAddressesFriendlyNameOffset { + t.Errorf("IPAdapterAddresses.FriendlyName offset is %d although %d is expected", offset, ipAdapterAddressesFriendlyNameOffset) + } + + offset = uintptr(unsafe.Pointer(&s.physicalAddress)) - sp + if offset != ipAdapterAddressesPhysicalAddressOffset { + t.Errorf("IPAdapterAddresses.PhysicalAddress offset is %d although %d is expected", offset, ipAdapterAddressesPhysicalAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.physicalAddressLength)) - sp + if offset != ipAdapterAddressesPhysicalAddressLengthOffset { + t.Errorf("IPAdapterAddresses.PhysicalAddressLength offset is %d although %d is expected", offset, ipAdapterAddressesPhysicalAddressLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Flags)) - sp + if offset != ipAdapterAddressesFlagsOffset { + t.Errorf("IPAdapterAddresses.Flags offset is %d although %d is expected", offset, ipAdapterAddressesFlagsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MTU)) - sp + if offset != ipAdapterAddressesMTUOffset { + t.Errorf("IPAdapterAddresses.MTU offset is %d although %d is expected", offset, ipAdapterAddressesMTUOffset) + } + + offset = uintptr(unsafe.Pointer(&s.IfType)) - sp + if offset != ipAdapterAddressesIfTypeOffset { + t.Errorf("IPAdapterAddresses.IfType offset is %d although %d is expected", offset, ipAdapterAddressesIfTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OperStatus)) - sp + if offset != ipAdapterAddressesOperStatusOffset { + t.Errorf("IPAdapterAddresses.OperStatus offset is %d although %d is expected", offset, ipAdapterAddressesOperStatusOffset) + } + + offset = uintptr(unsafe.Pointer(&s.IPv6IfIndex)) - sp + if offset != ipAdapterAddressesIPv6IfIndexOffset { + t.Errorf("IPAdapterAddresses.IPv6IfIndex offset is %d although %d is expected", offset, ipAdapterAddressesIPv6IfIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ZoneIndices)) - sp + if offset != ipAdapterAddressesZoneIndicesOffset { + t.Errorf("IPAdapterAddresses.ZoneIndices offset is %d although %d is expected", offset, ipAdapterAddressesZoneIndicesOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstPrefix)) - sp + if offset != ipAdapterAddressesFirstPrefixOffset { + t.Errorf("IPAdapterAddresses.FirstPrefix offset is %d although %d is expected", offset, ipAdapterAddressesFirstPrefixOffset) + } + + offset = uintptr(unsafe.Pointer(&s.TransmitLinkSpeed)) - sp + if offset != ipAdapterAddressesTransmitLinkSpeedOffset { + t.Errorf("IPAdapterAddresses.TransmitLinkSpeed offset is %d although %d is expected", offset, ipAdapterAddressesTransmitLinkSpeedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ReceiveLinkSpeed)) - sp + if offset != ipAdapterAddressesReceiveLinkSpeedOffset { + t.Errorf("IPAdapterAddresses.ReceiveLinkSpeed offset is %d although %d is expected", offset, ipAdapterAddressesReceiveLinkSpeedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstWINSServerAddress)) - sp + if offset != ipAdapterAddressesFirstWINSServerAddressOffset { + t.Errorf("IPAdapterAddresses.FirstWINSServerAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstWINSServerAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstGatewayAddress)) - sp + if offset != ipAdapterAddressesFirstGatewayAddressOffset { + t.Errorf("IPAdapterAddresses.FirstGatewayAddress offset is %d although %d is expected", offset, ipAdapterAddressesFirstGatewayAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Ipv4Metric)) - sp + if offset != ipAdapterAddressesIPv4MetricOffset { + t.Errorf("IPAdapterAddresses.IPv4Metric offset is %d although %d is expected", offset, ipAdapterAddressesIPv4MetricOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Ipv6Metric)) - sp + if offset != ipAdapterAddressesIPv6MetricOffset { + t.Errorf("IPAdapterAddresses.IPv6Metric offset is %d although %d is expected", offset, ipAdapterAddressesIPv6MetricOffset) + } + + offset = uintptr(unsafe.Pointer(&s.LUID)) - sp + if offset != ipAdapterAddressesLUIDOffset { + t.Errorf("IPAdapterAddresses.LUID offset is %d although %d is expected", offset, ipAdapterAddressesLUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DHCPv4Server)) - sp + if offset != ipAdapterAddressesDHCPv4ServerOffset { + t.Errorf("IPAdapterAddresses.DHCPv4Server offset is %d although %d is expected", offset, ipAdapterAddressesDHCPv4ServerOffset) + } + + offset = uintptr(unsafe.Pointer(&s.CompartmentID)) - sp + if offset != ipAdapterAddressesCompartmentIDOffset { + t.Errorf("IPAdapterAddresses.CompartmentID offset is %d although %d is expected", offset, ipAdapterAddressesCompartmentIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.NetworkGUID)) - sp + if offset != ipAdapterAddressesNetworkGUIDOffset { + t.Errorf("IPAdapterAddresses.NetworkGUID offset is %d although %d is expected", offset, ipAdapterAddressesNetworkGUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ConnectionType)) - sp + if offset != ipAdapterAddressesConnectionTypeOffset { + t.Errorf("IPAdapterAddresses.ConnectionType offset is %d although %d is expected", offset, ipAdapterAddressesConnectionTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.TunnelType)) - sp + if offset != ipAdapterAddressesTunnelTypeOffset { + t.Errorf("IPAdapterAddresses.TunnelType offset is %d although %d is expected", offset, ipAdapterAddressesTunnelTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DHCPv6Server)) - sp + if offset != ipAdapterAddressesDHCPv6ServerOffset { + t.Errorf("IPAdapterAddresses.DHCPv6Server offset is %d although %d is expected", offset, ipAdapterAddressesDHCPv6ServerOffset) + } + + offset = uintptr(unsafe.Pointer(&s.dhcpv6ClientDUID)) - sp + if offset != ipAdapterAddressesDHCPv6ClientDUIDOffset { + t.Errorf("IPAdapterAddresses.DHCPv6ClientDUID offset is %d although %d is expected", offset, ipAdapterAddressesDHCPv6ClientDUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.dhcpv6ClientDUIDLength)) - sp + if offset != ipAdapterAddressesDHCPv6ClientDUIDLengthOffset { + t.Errorf("IPAdapterAddresses.DHCPv6ClientDUIDLength offset is %d although %d is expected", offset, ipAdapterAddressesDHCPv6ClientDUIDLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DHCPv6IAID)) - sp + if offset != ipAdapterAddressesDHCPv6IAIDOffset { + t.Errorf("IPAdapterAddresses.DHCPv6IAID offset is %d although %d is expected", offset, ipAdapterAddressesDHCPv6IAIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.FirstDNSSuffix)) - sp + if offset != ipAdapterAddressesFirstDNSSuffixOffset { + t.Errorf("IPAdapterAddresses.FirstDNSSuffix offset is %d although %d is expected", offset, ipAdapterAddressesFirstDNSSuffixOffset) + } +} + +func TestMibIPInterfaceRow(t *testing.T) { + s := MibIPInterfaceRow{} + sp := uintptr(unsafe.Pointer(&s)) + const actualTestMibIPInterfaceRowSize = unsafe.Sizeof(s) + + if actualTestMibIPInterfaceRowSize != mibIPInterfaceRowSize { + t.Errorf("Size of MibIPInterfaceRow is %d, although %d is expected.", actualTestMibIPInterfaceRowSize, mibIPInterfaceRowSize) + } + + offset := uintptr(unsafe.Pointer(&s.InterfaceLUID)) - sp + if offset != mibIPInterfaceRowInterfaceLUIDOffset { + t.Errorf("MibIPInterfaceRow.InterfaceLUID offset is %d although %d is expected", offset, mibIPInterfaceRowInterfaceLUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceIndex)) - sp + if offset != mibIPInterfaceRowInterfaceIndexOffset { + t.Errorf("MibIPInterfaceRow.InterfaceIndex offset is %d although %d is expected", offset, mibIPInterfaceRowInterfaceIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MaxReassemblySize)) - sp + if offset != mibIPInterfaceRowMaxReassemblySizeOffset { + t.Errorf("mibIPInterfaceRow.MaxReassemblySize offset is %d although %d is expected", offset, mibIPInterfaceRowMaxReassemblySizeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceIdentifier)) - sp + if offset != mibIPInterfaceRowInterfaceIdentifierOffset { + t.Errorf("MibIPInterfaceRow.InterfaceIdentifier offset is %d although %d is expected", offset, mibIPInterfaceRowInterfaceIdentifierOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MinRouterAdvertisementInterval)) - sp + if offset != mibIPInterfaceRowMinRouterAdvertisementIntervalOffset { + t.Errorf("MibIPInterfaceRow.MinRouterAdvertisementInterval offset is %d although %d is expected", offset, mibIPInterfaceRowMinRouterAdvertisementIntervalOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MaxRouterAdvertisementInterval)) - sp + if offset != mibIPInterfaceRowMaxRouterAdvertisementIntervalOffset { + t.Errorf("MibIPInterfaceRow.MaxRouterAdvertisementInterval offset is %d although %d is expected", offset, mibIPInterfaceRowMaxRouterAdvertisementIntervalOffset) + } + + offset = uintptr(unsafe.Pointer(&s.AdvertisingEnabled)) - sp + if offset != mibIPInterfaceRowAdvertisingEnabledOffset { + t.Errorf("MibIPInterfaceRow.AdvertisingEnabled offset is %d although %d is expected", offset, mibIPInterfaceRowAdvertisingEnabledOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ForwardingEnabled)) - sp + if offset != mibIPInterfaceRowForwardingEnabledOffset { + t.Errorf("MibIPInterfaceRow.ForwardingEnabled offset is %d although %d is expected", offset, mibIPInterfaceRowForwardingEnabledOffset) + } + + offset = uintptr(unsafe.Pointer(&s.WeakHostSend)) - sp + if offset != mibIPInterfaceRowWeakHostSendOffset { + t.Errorf("MibIPInterfaceRow.WeakHostSend offset is %d although %d is expected", offset, mibIPInterfaceRowWeakHostSendOffset) + } + + offset = uintptr(unsafe.Pointer(&s.WeakHostReceive)) - sp + if offset != mibIPInterfaceRowWeakHostReceiveOffset { + t.Errorf("MibIPInterfaceRow.WeakHostReceive offset is %d although %d is expected", offset, mibIPInterfaceRowWeakHostReceiveOffset) + } + + offset = uintptr(unsafe.Pointer(&s.UseAutomaticMetric)) - sp + if offset != mibIPInterfaceRowUseAutomaticMetricOffset { + t.Errorf("MibIPInterfaceRow.UseAutomaticMetric offset is %d although %d is expected", offset, mibIPInterfaceRowUseAutomaticMetricOffset) + } + + offset = uintptr(unsafe.Pointer(&s.UseNeighborUnreachabilityDetection)) - sp + if offset != mibIPInterfaceRowUseNeighborUnreachabilityDetectionOffset { + t.Errorf("MibIPInterfaceRow.UseNeighborUnreachabilityDetection offset is %d although %d is expected", offset, mibIPInterfaceRowUseNeighborUnreachabilityDetectionOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ManagedAddressConfigurationSupported)) - sp + if offset != mibIPInterfaceRowManagedAddressConfigurationSupportedOffset { + t.Errorf("MibIPInterfaceRow.ManagedAddressConfigurationSupported offset is %d although %d is expected", offset, mibIPInterfaceRowManagedAddressConfigurationSupportedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OtherStatefulConfigurationSupported)) - sp + if offset != mibIPInterfaceRowOtherStatefulConfigurationSupportedOffset { + t.Errorf("MibIPInterfaceRow.OtherStatefulConfigurationSupported offset is %d although %d is expected", offset, mibIPInterfaceRowOtherStatefulConfigurationSupportedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.AdvertiseDefaultRoute)) - sp + if offset != mibIPInterfaceRowAdvertiseDefaultRouteOffset { + t.Errorf("MibIPInterfaceRow.AdvertiseDefaultRoute offset is %d although %d is expected", offset, mibIPInterfaceRowAdvertiseDefaultRouteOffset) + } + + offset = uintptr(unsafe.Pointer(&s.RouterDiscoveryBehavior)) - sp + if offset != mibIPInterfaceRowRouterDiscoveryBehaviorOffset { + t.Errorf("MibIPInterfaceRow.RouterDiscoveryBehavior offset is %d although %d is expected", offset, mibIPInterfaceRowRouterDiscoveryBehaviorOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DadTransmits)) - sp + if offset != mibIPInterfaceRowDadTransmitsOffset { + t.Errorf("MibIPInterfaceRow.DadTransmits offset is %d although %d is expected", offset, mibIPInterfaceRowDadTransmitsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.BaseReachableTime)) - sp + if offset != mibIPInterfaceRowBaseReachableTimeOffset { + t.Errorf("MibIPInterfaceRow.BaseReachableTime offset is %d although %d is expected", offset, mibIPInterfaceRowBaseReachableTimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.RetransmitTime)) - sp + if offset != mibIPInterfaceRowRetransmitTimeOffset { + t.Errorf("MibIPInterfaceRow.RetransmitTime offset is %d although %d is expected", offset, mibIPInterfaceRowRetransmitTimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.PathMTUDiscoveryTimeout)) - sp + if offset != mibIPInterfaceRowPathMTUDiscoveryTimeoutOffset { + t.Errorf("MibIPInterfaceRow.PathMTUDiscoveryTimeout offset is %d although %d is expected", offset, mibIPInterfaceRowPathMTUDiscoveryTimeoutOffset) + } + + offset = uintptr(unsafe.Pointer(&s.LinkLocalAddressBehavior)) - sp + if offset != mibIPInterfaceRowLinkLocalAddressBehaviorOffset { + t.Errorf("MibIPInterfaceRow.LinkLocalAddressBehavior offset is %d although %d is expected", offset, mibIPInterfaceRowLinkLocalAddressBehaviorOffset) + } + + offset = uintptr(unsafe.Pointer(&s.LinkLocalAddressTimeout)) - sp + if offset != mibIPInterfaceRowLinkLocalAddressTimeoutOffset { + t.Errorf("MibIPInterfaceRow.LinkLocalAddressTimeout offset is %d although %d is expected", offset, mibIPInterfaceRowLinkLocalAddressTimeoutOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ZoneIndices)) - sp + if offset != mibIPInterfaceRowZoneIndicesOffset { + t.Errorf("MibIPInterfaceRow.ZoneIndices offset is %d although %d is expected", offset, mibIPInterfaceRowZoneIndicesOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SitePrefixLength)) - sp + if offset != mibIPInterfaceRowSitePrefixLengthOffset { + t.Errorf("MibIPInterfaceRow.SitePrefixLength offset is %d although %d is expected", offset, mibIPInterfaceRowSitePrefixLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Metric)) - sp + if offset != mibIPInterfaceRowMetricOffset { + t.Errorf("MibIPInterfaceRow.Metric offset is %d although %d is expected", offset, mibIPInterfaceRowMetricOffset) + } + + offset = uintptr(unsafe.Pointer(&s.NLMTU)) - sp + if offset != mibIPInterfaceRowNLMTUOffset { + t.Errorf("MibIPInterfaceRow.NLMTU offset is %d although %d is expected", offset, mibIPInterfaceRowNLMTUOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Connected)) - sp + if offset != mibIPInterfaceRowConnectedOffset { + t.Errorf("MibIPInterfaceRow.Connected offset is %d although %d is expected", offset, mibIPInterfaceRowConnectedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SupportsWakeUpPatterns)) - sp + if offset != mibIPInterfaceRowSupportsWakeUpPatternsOffset { + t.Errorf("MibIPInterfaceRow.SupportsWakeUpPatterns offset is %d although %d is expected", offset, mibIPInterfaceRowSupportsWakeUpPatternsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SupportsNeighborDiscovery)) - sp + if offset != mibIPInterfaceRowSupportsNeighborDiscoveryOffset { + t.Errorf("MibIPInterfaceRow.SupportsNeighborDiscovery offset is %d although %d is expected", offset, mibIPInterfaceRowSupportsNeighborDiscoveryOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SupportsRouterDiscovery)) - sp + if offset != mibIPInterfaceRowSupportsRouterDiscoveryOffset { + t.Errorf("MibIPInterfaceRow.SupportsRouterDiscovery offset is %d although %d is expected", offset, mibIPInterfaceRowSupportsRouterDiscoveryOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ReachableTime)) - sp + if offset != mibIPInterfaceRowReachableTimeOffset { + t.Errorf("MibIPInterfaceRow.ReachableTime offset is %d although %d is expected", offset, mibIPInterfaceRowReachableTimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.TransmitOffload)) - sp + if offset != mibIPInterfaceRowTransmitOffloadOffset { + t.Errorf("MibIPInterfaceRow.TransmitOffload offset is %d although %d is expected", offset, mibIPInterfaceRowTransmitOffloadOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ReceiveOffload)) - sp + if offset != mibIPInterfaceRowReceiveOffloadOffset { + t.Errorf("MibIPInterfaceRow.ReceiveOffload offset is %d although %d is expected", offset, mibIPInterfaceRowReceiveOffloadOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DisableDefaultRoutes)) - sp + if offset != mibIPInterfaceRowDisableDefaultRoutesOffset { + t.Errorf("MibIPInterfaceRow.DisableDefaultRoutes offset is %d although %d is expected", offset, mibIPInterfaceRowDisableDefaultRoutesOffset) + } +} + +func TestMibIPInterfaceTable(t *testing.T) { + s := mibIPInterfaceTable{} + sp := uintptr(unsafe.Pointer(&s)) + const actualmibIPInterfaceTableSize = unsafe.Sizeof(s) + + if actualmibIPInterfaceTableSize != mibIPInterfaceTableSize { + t.Errorf("Size of mibIPInterfaceTable is %d, although %d is expected.", actualmibIPInterfaceTableSize, mibIPInterfaceTableSize) + } + + offset := uintptr(unsafe.Pointer(&s.table)) - sp + if offset != mibIPInterfaceTableTableOffset { + t.Errorf("mibIPInterfaceTable.table offset is %d although %d is expected", offset, mibIPInterfaceTableTableOffset) + } +} + +func TestMibIfRow2(t *testing.T) { + s := MibIfRow2{} + sp := uintptr(unsafe.Pointer(&s)) + const actualMibIfRow2Size = unsafe.Sizeof(s) + + if actualMibIfRow2Size != mibIfRow2Size { + t.Errorf("Size of MibIfRow2 is %d, although %d is expected.", actualMibIfRow2Size, mibIfRow2Size) + } + + offset := uintptr(unsafe.Pointer(&s.InterfaceIndex)) - sp + if offset != mibIfRow2InterfaceIndexOffset { + t.Errorf("MibIfRow2.InterfaceIndex offset is %d although %d is expected", offset, mibIfRow2InterfaceIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceGUID)) - sp + if offset != mibIfRow2InterfaceGUIDOffset { + t.Errorf("MibIfRow2.InterfaceGUID offset is %d although %d is expected", offset, mibIfRow2InterfaceGUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.alias)) - sp + if offset != mibIfRow2AliasOffset { + t.Errorf("MibIfRow2.alias offset is %d although %d is expected", offset, mibIfRow2AliasOffset) + } + + offset = uintptr(unsafe.Pointer(&s.description)) - sp + if offset != mibIfRow2DescriptionOffset { + t.Errorf("MibIfRow2.description offset is %d although %d is expected", offset, mibIfRow2DescriptionOffset) + } + + offset = uintptr(unsafe.Pointer(&s.physicalAddressLength)) - sp + if offset != mibIfRow2PhysicalAddressLengthOffset { + t.Errorf("MibIfRow2.physicalAddressLength offset is %d although %d is expected", offset, mibIfRow2PhysicalAddressLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.physicalAddress)) - sp + if offset != mibIfRow2PhysicalAddressOffset { + t.Errorf("MibIfRow2.physicalAddress offset is %d although %d is expected", offset, mibIfRow2PhysicalAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.permanentPhysicalAddress)) - sp + if offset != mibIfRow2PermanentPhysicalAddressOffset { + t.Errorf("MibIfRow2.permanentPhysicalAddress offset is %d although %d is expected", offset, mibIfRow2PermanentPhysicalAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MTU)) - sp + if offset != mibIfRow2MTUOffset { + t.Errorf("MibIfRow2.MTU offset is %d although %d is expected", offset, mibIfRow2MTUOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Type)) - sp + if offset != mibIfRow2TypeOffset { + t.Errorf("MibIfRow2.Type offset is %d although %d is expected", offset, mibIfRow2TypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.TunnelType)) - sp + if offset != mibIfRow2TunnelTypeOffset { + t.Errorf("MibIfRow2.TunnelType offset is %d although %d is expected", offset, mibIfRow2TunnelTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MediaType)) - sp + if offset != mibIfRow2MediaTypeOffset { + t.Errorf("MibIfRow2.MediaType offset is %d although %d is expected", offset, mibIfRow2MediaTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.PhysicalMediumType)) - sp + if offset != mibIfRow2PhysicalMediumTypeOffset { + t.Errorf("MibIfRow2.PhysicalMediumType offset is %d although %d is expected", offset, mibIfRow2PhysicalMediumTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.AccessType)) - sp + if offset != mibIfRow2AccessTypeOffset { + t.Errorf("MibIfRow2.AccessType offset is %d although %d is expected", offset, mibIfRow2AccessTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DirectionType)) - sp + if offset != mibIfRow2DirectionTypeOffset { + t.Errorf("MibIfRow2.DirectionType offset is %d although %d is expected", offset, mibIfRow2DirectionTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceAndOperStatusFlags)) - sp + if offset != mibIfRow2InterfaceAndOperStatusFlagsOffset { + t.Errorf("MibIfRow2.InterfaceAndOperStatusFlags offset is %d although %d is expected", offset, mibIfRow2InterfaceAndOperStatusFlagsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OperStatus)) - sp + if offset != mibIfRow2OperStatusOffset { + t.Errorf("MibIfRow2.OperStatus offset is %d although %d is expected", offset, mibIfRow2OperStatusOffset) + } + + offset = uintptr(unsafe.Pointer(&s.AdminStatus)) - sp + if offset != mibIfRow2AdminStatusOffset { + t.Errorf("MibIfRow2.AdminStatus offset is %d although %d is expected", offset, mibIfRow2AdminStatusOffset) + } + + offset = uintptr(unsafe.Pointer(&s.MediaConnectState)) - sp + if offset != mibIfRow2MediaConnectStateOffset { + t.Errorf("MibIfRow2.MediaConnectState offset is %d although %d is expected", offset, mibIfRow2MediaConnectStateOffset) + } + + offset = uintptr(unsafe.Pointer(&s.NetworkGUID)) - sp + if offset != mibIfRow2NetworkGUIDOffset { + t.Errorf("MibIfRow2.NetworkGUID offset is %d although %d is expected", offset, mibIfRow2NetworkGUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ConnectionType)) - sp + if offset != mibIfRow2ConnectionTypeOffset { + t.Errorf("MibIfRow2.ConnectionType offset is %d although %d is expected", offset, mibIfRow2ConnectionTypeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.TransmitLinkSpeed)) - sp + if offset != mibIfRow2TransmitLinkSpeedOffset { + t.Errorf("MibIfRow2.TransmitLinkSpeed offset is %d although %d is expected", offset, mibIfRow2TransmitLinkSpeedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ReceiveLinkSpeed)) - sp + if offset != mibIfRow2ReceiveLinkSpeedOffset { + t.Errorf("MibIfRow2.ReceiveLinkSpeed offset is %d although %d is expected", offset, mibIfRow2ReceiveLinkSpeedOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InOctets)) - sp + if offset != mibIfRow2InOctetsOffset { + t.Errorf("MibIfRow2.InOctets offset is %d although %d is expected", offset, mibIfRow2InOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InUcastPkts)) - sp + if offset != mibIfRow2InUcastPktsOffset { + t.Errorf("MibIfRow2.InUcastPkts offset is %d although %d is expected", offset, mibIfRow2InUcastPktsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InNUcastPkts)) - sp + if offset != mibIfRow2InNUcastPktsOffset { + t.Errorf("MibIfRow2.InNUcastPkts offset is %d although %d is expected", offset, mibIfRow2InNUcastPktsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InDiscards)) - sp + if offset != mibIfRow2InDiscardsOffset { + t.Errorf("MibIfRow2.InDiscards offset is %d although %d is expected", offset, mibIfRow2InDiscardsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InErrors)) - sp + if offset != mibIfRow2InErrorsOffset { + t.Errorf("MibIfRow2.InErrors offset is %d although %d is expected", offset, mibIfRow2InErrorsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InUnknownProtos)) - sp + if offset != mibIfRow2InUnknownProtosOffset { + t.Errorf("MibIfRow2.InUnknownProtos offset is %d although %d is expected", offset, mibIfRow2InUnknownProtosOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InUcastOctets)) - sp + if offset != mibIfRow2InUcastOctetsOffset { + t.Errorf("MibIfRow2.InUcastOctets offset is %d although %d is expected", offset, mibIfRow2InUcastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InMulticastOctets)) - sp + if offset != mibIfRow2InMulticastOctetsOffset { + t.Errorf("MibIfRow2.InMulticastOctets offset is %d although %d is expected", offset, mibIfRow2InMulticastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InBroadcastOctets)) - sp + if offset != mibIfRow2InBroadcastOctetsOffset { + t.Errorf("MibIfRow2.InBroadcastOctets offset is %d although %d is expected", offset, mibIfRow2InBroadcastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutOctets)) - sp + if offset != mibIfRow2OutOctetsOffset { + t.Errorf("MibIfRow2.OutOctets offset is %d although %d is expected", offset, mibIfRow2OutOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutUcastPkts)) - sp + if offset != mibIfRow2OutUcastPktsOffset { + t.Errorf("MibIfRow2.OutUcastPkts offset is %d although %d is expected", offset, mibIfRow2OutUcastPktsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutNUcastPkts)) - sp + if offset != mibIfRow2OutNUcastPktsOffset { + t.Errorf("MibIfRow2.OutNUcastPkts offset is %d although %d is expected", offset, mibIfRow2OutNUcastPktsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutDiscards)) - sp + if offset != mibIfRow2OutDiscardsOffset { + t.Errorf("MibIfRow2.OutDiscards offset is %d although %d is expected", offset, mibIfRow2OutDiscardsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutErrors)) - sp + if offset != mibIfRow2OutErrorsOffset { + t.Errorf("MibIfRow2.OutErrors offset is %d although %d is expected", offset, mibIfRow2OutErrorsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutUcastOctets)) - sp + if offset != mibIfRow2OutUcastOctetsOffset { + t.Errorf("MibIfRow2.OutUcastOctets offset is %d although %d is expected", offset, mibIfRow2OutUcastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutMulticastOctets)) - sp + if offset != mibIfRow2OutMulticastOctetsOffset { + t.Errorf("MibIfRow2.OutMulticastOctets offset is %d although %d is expected", offset, mibIfRow2OutMulticastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutBroadcastOctets)) - sp + if offset != mibIfRow2OutBroadcastOctetsOffset { + t.Errorf("MibIfRow2.OutBroadcastOctets offset is %d although %d is expected", offset, mibIfRow2OutBroadcastOctetsOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OutQLen)) - sp + if offset != mibIfRow2OutQLenOffset { + t.Errorf("MibIfRow2.OutQLen offset is %d although %d is expected", offset, mibIfRow2OutQLenOffset) + } +} + +func TestMibIfTable2(t *testing.T) { + s := mibIfTable2{} + sp := uintptr(unsafe.Pointer(&s)) + const actualmibIfTable2Size = unsafe.Sizeof(s) + + if actualmibIfTable2Size != mibIfTable2Size { + t.Errorf("Size of mibIfTable2 is %d, although %d is expected.", actualmibIfTable2Size, mibIfTable2Size) + } + + offset := uintptr(unsafe.Pointer(&s.table)) - sp + if offset != mibIfTable2TableOffset { + t.Errorf("mibIfTable2.table offset is %d although %d is expected", offset, mibIfTable2TableOffset) + } +} + +func TestRawSockaddrInet(t *testing.T) { + s := RawSockaddrInet{} + sp := uintptr(unsafe.Pointer(&s)) + const actualRawSockaddrInetSize = unsafe.Sizeof(s) + + if actualRawSockaddrInetSize != rawSockaddrInetSize { + t.Errorf("Size of RawSockaddrInet is %d, although %d is expected.", actualRawSockaddrInetSize, rawSockaddrInetSize) + } + + offset := uintptr(unsafe.Pointer(&s.data)) - sp + if offset != rawSockaddrInetDataOffset { + t.Errorf("RawSockaddrInet.data offset is %d although %d is expected", offset, rawSockaddrInetDataOffset) + } +} + +func TestMibUnicastIPAddressRow(t *testing.T) { + s := MibUnicastIPAddressRow{} + sp := uintptr(unsafe.Pointer(&s)) + const actualMibUnicastIPAddressRowSize = unsafe.Sizeof(s) + + if actualMibUnicastIPAddressRowSize != mibUnicastIPAddressRowSize { + t.Errorf("Size of MibUnicastIPAddressRow is %d, although %d is expected.", actualMibUnicastIPAddressRowSize, mibUnicastIPAddressRowSize) + } + + offset := uintptr(unsafe.Pointer(&s.InterfaceLUID)) - sp + if offset != mibUnicastIPAddressRowInterfaceLUIDOffset { + t.Errorf("MibUnicastIPAddressRow.InterfaceLUID offset is %d although %d is expected", offset, mibUnicastIPAddressRowInterfaceLUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceIndex)) - sp + if offset != mibUnicastIPAddressRowInterfaceIndexOffset { + t.Errorf("MibUnicastIPAddressRow.InterfaceIndex offset is %d although %d is expected", offset, mibUnicastIPAddressRowInterfaceIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.PrefixOrigin)) - sp + if offset != mibUnicastIPAddressRowPrefixOriginOffset { + t.Errorf("MibUnicastIPAddressRow.PrefixOrigin offset is %d although %d is expected", offset, mibUnicastIPAddressRowPrefixOriginOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SuffixOrigin)) - sp + if offset != mibUnicastIPAddressRowSuffixOriginOffset { + t.Errorf("MibUnicastIPAddressRow.SuffixOrigin offset is %d although %d is expected", offset, mibUnicastIPAddressRowSuffixOriginOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ValidLifetime)) - sp + if offset != mibUnicastIPAddressRowValidLifetimeOffset { + t.Errorf("MibUnicastIPAddressRow.ValidLifetime offset is %d although %d is expected", offset, mibUnicastIPAddressRowValidLifetimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.PreferredLifetime)) - sp + if offset != mibUnicastIPAddressRowPreferredLifetimeOffset { + t.Errorf("MibUnicastIPAddressRow.PreferredLifetime offset is %d although %d is expected", offset, mibUnicastIPAddressRowPreferredLifetimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.OnLinkPrefixLength)) - sp + if offset != mibUnicastIPAddressRowOnLinkPrefixLengthOffset { + t.Errorf("MibUnicastIPAddressRow.OnLinkPrefixLength offset is %d although %d is expected", offset, mibUnicastIPAddressRowOnLinkPrefixLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SkipAsSource)) - sp + if offset != mibUnicastIPAddressRowSkipAsSourceOffset { + t.Errorf("MibUnicastIPAddressRow.SkipAsSource offset is %d although %d is expected", offset, mibUnicastIPAddressRowSkipAsSourceOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DadState)) - sp + if offset != mibUnicastIPAddressRowDadStateOffset { + t.Errorf("MibUnicastIPAddressRow.DadState offset is %d although %d is expected", offset, mibUnicastIPAddressRowDadStateOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ScopeID)) - sp + if offset != mibUnicastIPAddressRowScopeIDOffset { + t.Errorf("MibUnicastIPAddressRow.ScopeID offset is %d although %d is expected", offset, mibUnicastIPAddressRowScopeIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.CreationTimeStamp)) - sp + if offset != mibUnicastIPAddressRowCreationTimeStampOffset { + t.Errorf("MibUnicastIPAddressRow.CreationTimeStamp offset is %d although %d is expected", offset, mibUnicastIPAddressRowCreationTimeStampOffset) + } +} + +func TestMibUnicastIPAddressTable(t *testing.T) { + s := mibUnicastIPAddressTable{} + sp := uintptr(unsafe.Pointer(&s)) + const actualmibUnicastIPAddressTableSize = unsafe.Sizeof(s) + + if actualmibUnicastIPAddressTableSize != mibUnicastIPAddressTableSize { + t.Errorf("Size of mibUnicastIPAddressTable is %d, although %d is expected.", actualmibUnicastIPAddressTableSize, mibUnicastIPAddressTableSize) + } + + offset := uintptr(unsafe.Pointer(&s.table)) - sp + if offset != mibUnicastIPAddressTableTableOffset { + t.Errorf("mibUnicastIPAddressTable.table offset is %d although %d is expected", offset, mibUnicastIPAddressTableTableOffset) + } +} + +func TestMibAnycastIPAddressRow(t *testing.T) { + s := MibAnycastIPAddressRow{} + sp := uintptr(unsafe.Pointer(&s)) + const actualMibAnycastIPAddressRowSize = unsafe.Sizeof(s) + + if actualMibAnycastIPAddressRowSize != mibAnycastIPAddressRowSize { + t.Errorf("Size of MibAnycastIPAddressRow is %d, although %d is expected.", actualMibAnycastIPAddressRowSize, mibAnycastIPAddressRowSize) + } + + offset := uintptr(unsafe.Pointer(&s.InterfaceLUID)) - sp + if offset != mibAnycastIPAddressRowInterfaceLUIDOffset { + t.Errorf("MibAnycastIPAddressRow.InterfaceLUID offset is %d although %d is expected", offset, mibAnycastIPAddressRowInterfaceLUIDOffset) + } + + offset = uintptr(unsafe.Pointer(&s.InterfaceIndex)) - sp + if offset != mibAnycastIPAddressRowInterfaceIndexOffset { + t.Errorf("MibAnycastIPAddressRow.InterfaceIndex offset is %d although %d is expected", offset, mibAnycastIPAddressRowInterfaceIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ScopeID)) - sp + if offset != mibAnycastIPAddressRowScopeIDOffset { + t.Errorf("MibAnycastIPAddressRow.ScopeID offset is %d although %d is expected", offset, mibAnycastIPAddressRowScopeIDOffset) + } +} + +func TestMibAnycastIPAddressTable(t *testing.T) { + s := mibAnycastIPAddressTable{} + sp := uintptr(unsafe.Pointer(&s)) + const actualmibAnycastIPAddressTableSize = unsafe.Sizeof(s) + + if actualmibAnycastIPAddressTableSize != mibAnycastIPAddressTableSize { + t.Errorf("Size of mibAnycastIPAddressTable is %d, although %d is expected.", actualmibAnycastIPAddressTableSize, mibAnycastIPAddressTableSize) + } + + offset := uintptr(unsafe.Pointer(&s.table)) - sp + if offset != mibAnycastIPAddressTableTableOffset { + t.Errorf("mibAnycastIPAddressTable.table offset is %d although %d is expected", offset, mibAnycastIPAddressTableTableOffset) + } +} + +func TestIPAddressPrefix(t *testing.T) { + s := IPAddressPrefix{} + sp := uintptr(unsafe.Pointer(&s)) + const actualIPAddressPrefixSize = unsafe.Sizeof(s) + + if actualIPAddressPrefixSize != ipAddressPrefixSize { + t.Errorf("Size of IPAddressPrefix is %d, although %d is expected.", actualIPAddressPrefixSize, ipAddressPrefixSize) + } + + offset := uintptr(unsafe.Pointer(&s.PrefixLength)) - sp + if offset != ipAddressPrefixPrefixLengthOffset { + t.Errorf("IPAddressPrefix.PrefixLength offset is %d although %d is expected", offset, ipAddressPrefixPrefixLengthOffset) + + } +} + +func TestMibIPforwardRow2(t *testing.T) { + s := MibIPforwardRow2{} + sp := uintptr(unsafe.Pointer(&s)) + const actualMibIPforwardRow2Size = unsafe.Sizeof(s) + + if actualMibIPforwardRow2Size != mibIPforwardRow2Size { + t.Errorf("Size of MibIPforwardRow2 is %d, although %d is expected.", actualMibIPforwardRow2Size, mibIPforwardRow2Size) + } + + offset := uintptr(unsafe.Pointer(&s.InterfaceIndex)) - sp + if offset != mibIPforwardRow2InterfaceIndexOffset { + t.Errorf("MibIPforwardRow2.InterfaceIndex offset is %d although %d is expected", offset, mibIPforwardRow2InterfaceIndexOffset) + } + + offset = uintptr(unsafe.Pointer(&s.DestinationPrefix)) - sp + if offset != mibIPforwardRow2DestinationPrefixOffset { + t.Errorf("MibIPforwardRow2.DestinationPrefix offset is %d although %d is expected", offset, mibIPforwardRow2DestinationPrefixOffset) + } + + offset = uintptr(unsafe.Pointer(&s.NextHop)) - sp + if offset != mibIPforwardRow2NextHopOffset { + t.Errorf("MibIPforwardRow2.NextHop offset is %d although %d is expected", offset, mibIPforwardRow2NextHopOffset) + } + + offset = uintptr(unsafe.Pointer(&s.SitePrefixLength)) - sp + if offset != mibIPforwardRow2SitePrefixLengthOffset { + t.Errorf("MibIPforwardRow2.SitePrefixLength offset is %d although %d is expected", offset, mibIPforwardRow2SitePrefixLengthOffset) + } + + offset = uintptr(unsafe.Pointer(&s.ValidLifetime)) - sp + if offset != mibIPforwardRow2ValidLifetimeOffset { + t.Errorf("MibIPforwardRow2.ValidLifetime offset is %d although %d is expected", offset, mibIPforwardRow2ValidLifetimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.PreferredLifetime)) - sp + if offset != mibIPforwardRow2PreferredLifetimeOffset { + t.Errorf("MibIPforwardRow2.PreferredLifetime offset is %d although %d is expected", offset, mibIPforwardRow2PreferredLifetimeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Metric)) - sp + if offset != mibIPforwardRow2MetricOffset { + t.Errorf("MibIPforwardRow2.Metric offset is %d although %d is expected", offset, mibIPforwardRow2MetricOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Protocol)) - sp + if offset != mibIPforwardRow2ProtocolOffset { + t.Errorf("MibIPforwardRow2.Protocol offset is %d although %d is expected", offset, mibIPforwardRow2ProtocolOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Loopback)) - sp + if offset != mibIPforwardRow2LoopbackOffset { + t.Errorf("MibIPforwardRow2.Loopback offset is %d although %d is expected", offset, mibIPforwardRow2LoopbackOffset) + } + + offset = uintptr(unsafe.Pointer(&s.AutoconfigureAddress)) - sp + if offset != mibIPforwardRow2AutoconfigureAddressOffset { + t.Errorf("MibIPforwardRow2.AutoconfigureAddress offset is %d although %d is expected", offset, mibIPforwardRow2AutoconfigureAddressOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Publish)) - sp + if offset != mibIPforwardRow2PublishOffset { + t.Errorf("MibIPforwardRow2.Publish offset is %d although %d is expected", offset, mibIPforwardRow2PublishOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Immortal)) - sp + if offset != mibIPforwardRow2ImmortalOffset { + t.Errorf("MibIPforwardRow2.Immortal offset is %d although %d is expected", offset, mibIPforwardRow2ImmortalOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Age)) - sp + if offset != mibIPforwardRow2AgeOffset { + t.Errorf("MibIPforwardRow2.Age offset is %d although %d is expected", offset, mibIPforwardRow2AgeOffset) + } + + offset = uintptr(unsafe.Pointer(&s.Origin)) - sp + if offset != mibIPforwardRow2OriginOffset { + t.Errorf("MibIPforwardRow2.Origin offset is %d although %d is expected", offset, mibIPforwardRow2OriginOffset) + } +} + +func TestMibIPforwardTable2(t *testing.T) { + s := mibIPforwardTable2{} + sp := uintptr(unsafe.Pointer(&s)) + const actualmibIPforwardTable2Size = unsafe.Sizeof(s) + + if actualmibIPforwardTable2Size != mibIPforwardTable2Size { + t.Errorf("Size of mibIPforwardTable2 is %d, although %d is expected.", actualmibIPforwardTable2Size, mibIPforwardTable2Size) + } + + offset := uintptr(unsafe.Pointer(&s.table)) - sp + if offset != mibIPforwardTable2TableOffset { + t.Errorf("mibIPforwardTable2.table offset is %d although %d is expected", offset, mibIPforwardTable2TableOffset) + } +} |