zircon/system/dev/ethernet/ethernet/ethernet-test.cpp - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ethernet.h"

 #include <ddk/debug.h>
 #include <ddk/device.h>
 #include <lib/fake_ddk/fake_ddk.h>
 #include <lib/zx/process.h>
 #include <thread>
 #include <zxtest/zxtest.h>

 class FakeEthmacProtocol : public ddk::Device<FakeEthmacProtocol, ddk::GetProtocolable>,
                            public ddk::EthmacProtocol<FakeEthmacProtocol, ddk::base_protocol> {
 public:
     FakeEthmacProtocol()
         : ddk::Device<FakeEthmacProtocol, ddk::GetProtocolable>(fake_ddk::kFakeDevice),
           proto_({&ethmac_protocol_ops_, this}) {
     }

     const ethmac_protocol_t* proto() const { return &proto_; }

     void DdkRelease() {}

     zx_status_t EthmacQuery(uint32_t options, ethmac_info_t* info) {
         info->netbuf_size = sizeof(ethmac_netbuf_t);
         info->mtu = 1500;
         memcpy(info->mac, mac_, sizeof(info->mac));
         return ZX_OK;
     }

     void EthmacStop() {}

     zx_status_t EthmacStart(const ethmac_ifc_protocol_t* ifc) {
         client_ = std::make_unique<ddk::EthmacIfcProtocolClient>(ifc);
         return ZX_OK;
     }

     zx_status_t EthmacQueueTx(uint32_t options, ethmac_netbuf_t* netbuf) {
         queue_tx_called_ = true;
         return ZX_OK;
     }

     zx_status_t EthmacSetParam(uint32_t param, int32_t value, const void* data, size_t data_size) {
         if (param == ETHMAC_SETPARAM_DUMP_REGS) {
             dump_called_ = true;
         }
         return ZX_OK;
     }
     void EthmacGetBti(zx::bti* bti) { bti->reset(); }

     bool TestInfo(fuchsia_hardware_ethernet_Info* info) {
         if (memcmp(mac_, info->mac.octets, ETH_MAC_SIZE) || (info->mtu != 1500)) {
             return false;
         }
         return true;
     }

     bool TestDump() { return dump_called_; }

     bool TestIfc() {
         if (!client_)
             return false;
         // Use the provided client to test the ifc client.
         client_->Status(0);
         client_->Recv(nullptr, 0, 0);
         client_->CompleteTx(nullptr, ZX_OK);
         return true;
     }

     bool SetStatus(uint32_t status) {
         if (!client_)
             return false;
         client_->Status(status);
         return true;
     }

     bool TestQueueTx() {
         return queue_tx_called_;
     }

     bool TestRecv() {
         if (!client_) {
             return false;
         }
         uint8_t data = 0xAA;
         client_->Recv(&data, 1, 0);
         return true;
     }

 private:
     ethmac_protocol_t proto_;
     const uint8_t mac_[ETH_MAC_SIZE] = {0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
     fbl::unique_ptr<ddk::EthmacIfcProtocolClient> client_;

     bool dump_called_ = false;
     bool queue_tx_called_ = false;
 };

 class EthernetTester {
 public:
     EthernetTester() {
         fbl::Array<fake_ddk::ProtocolEntry> protocols(new fake_ddk::ProtocolEntry[1], 1);
         protocols[0] = {ZX_PROTOCOL_ETHMAC,
                         *reinterpret_cast<const fake_ddk::Protocol*>(ethmac_.proto())};
         ddk_.SetProtocols(std::move(protocols));
     }

     fake_ddk::Bind& ddk() { return ddk_; }
     FakeEthmacProtocol& ethmac() { return ethmac_; }

 private:
     fake_ddk::Bind ddk_;
     FakeEthmacProtocol ethmac_;
 };

 TEST(EthernetTest, BindTest) {
     EthernetTester tester;
     EXPECT_EQ(eth::EthDev0::EthBind(nullptr, fake_ddk::kFakeParent), ZX_OK, "Bind failed");
 }

 TEST(EthernetTest, DdkLifecycleTest) {
     EthernetTester tester;
     eth::EthDev0* eth(new eth::EthDev0(fake_ddk::kFakeParent));
     EXPECT_EQ(eth->AddDevice(), ZX_OK, "AddDevice Failed");
     eth->DdkUnbind();
     EXPECT_TRUE(tester.ddk().Ok());
     eth->DdkRelease();
 }

 TEST(EthernetTest, OpenTest) {
     EthernetTester tester;
     eth::EthDev0* eth(new eth::EthDev0(fake_ddk::kFakeParent));
     EXPECT_EQ(eth->AddDevice(), ZX_OK, "AddDevice Failed");
     zx_device_t* eth_instance;
     EXPECT_EQ(eth->DdkOpen(&eth_instance, 0), ZX_OK, "Open Failed");
     eth->DdkUnbind();
     eth->DdkRelease();
 }

 class EthernetDeviceTest {
 public:
     EthernetDeviceTest()
         : tester() {

         edev0 = std::make_unique<eth::EthDev0>(fake_ddk::kFakeParent);
         ASSERT_OK(edev0->AddDevice());

         edev = fbl::MakeRefCounted<eth::EthDev>(fake_ddk::kFakeParent, edev0.get());
         zx_device_t* out;
         ASSERT_OK(edev->AddDevice(&out));
     }

     void Start() {
         zx_status_t out_status = ZX_ERR_INTERNAL;
         fuchsia_hardware_ethernet_Fifos fifos = {};
         ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetFifos(FidlChannel(), &out_status, &fifos));
         tx_fifo_ = zx::fifo(fifos.tx);
         EXPECT_TRUE(tx_fifo_.is_valid());
         rx_fifo_ = zx::fifo(fifos.rx);
         rx_fifo_depth_ = fifos.rx_depth;
         tx_fifo_depth_ = fifos.tx_depth;
         EXPECT_TRUE(rx_fifo_.is_valid());
         ASSERT_OK(zx::vmo::create(2 * sizeof(ethmac_netbuf_t), ZX_VMO_NON_RESIZABLE, &buf_));
         ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetIOBuffer(FidlChannel(),
                                                               buf_.get(), &out_status));
         ASSERT_OK(out_status);
         ASSERT_OK(fuchsia_hardware_ethernet_DeviceStart(FidlChannel(), &out_status));
         ASSERT_OK(out_status);
     }

     zx_handle_t FidlChannel() { return tester.ddk().FidlClient().get(); }

     zx::fifo& TransmitFifo() { return tx_fifo_; }

     zx::fifo& ReceiveFifo() { return rx_fifo_; }

     EthernetTester tester;
     fbl::unique_ptr<eth::EthDev0> edev0;
     fbl::RefPtr<eth::EthDev> edev;

 private:
     zx::fifo tx_fifo_;
     zx::fifo rx_fifo_;
     uint32_t rx_fifo_depth_;
     uint32_t tx_fifo_depth_;
     zx::vmo buf_;
 };

 TEST(EthernetTest, MultipleOpenTest) {
     EthernetDeviceTest test;
     EXPECT_EQ(test.edev->DdkOpen(nullptr, 0), ZX_OK, "Instance 1 open failed");
     EXPECT_EQ(test.edev->DdkOpen(nullptr, 0), ZX_OK, "Instance 2 open failed");
     EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 0 close failed");
     EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 1 close failed");
     EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 2 close failed");
 }

 TEST(EthernetTest, SetClientNameTest) {
     EthernetDeviceTest test;
     zx_status_t call_status = ZX_OK;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetClientName(test.FidlChannel(),
                                                             "ethtest",
                                                             strlen("ethtest"),
                                                             &call_status));
     ASSERT_OK(call_status);
 }

 TEST(EthernetTest, GetInfoTest) {
     EthernetDeviceTest test;
     fuchsia_hardware_ethernet_Info info = {};
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetInfo(test.FidlChannel(),
                                                       &info));
     EXPECT_TRUE(test.tester.ethmac().TestInfo(&info));
 }

 TEST(EthernetTest, GetFifosTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     fuchsia_hardware_ethernet_Fifos fifos = {};

     ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetFifos(test.FidlChannel(), &out_status, &fifos));
     ASSERT_OK(out_status);
     EXPECT_TRUE(fifos.rx != ZX_HANDLE_INVALID);
     EXPECT_TRUE(fifos.tx != ZX_HANDLE_INVALID);
 }

 TEST(EthernetTest, SetPromiscuousModeTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;

     ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetPromiscuousMode(test.FidlChannel(),
                                                                  true, &out_status));
     ASSERT_OK(out_status);

     out_status = ZX_ERR_INTERNAL;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetPromiscuousMode(test.FidlChannel(),
                                                                  false, &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, ConfigMulticastAddMacTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     /* 1st bit should be 1 in multicast */
     fuchsia_hardware_ethernet_MacAddress wrong_addr =
         {.octets = {0x00, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastAddMac(test.FidlChannel(),
                                                                     &wrong_addr, &out_status));
     ASSERT_OK(!out_status);
     fuchsia_hardware_ethernet_MacAddress right_addr =
         {.octets = {0x01, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastAddMac(test.FidlChannel(),
                                                                     &right_addr, &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, ConfigMulticastDeleteMacTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     fuchsia_hardware_ethernet_MacAddress addr = {.octets = {0xaa, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMac(test.FidlChannel(),
                                                                        &addr, &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, ConfigMulticastSetPromiscuousModeTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousMode(test.FidlChannel(),
                                                                                 true, &out_status));
     ASSERT_OK(out_status);

     out_status = ZX_ERR_INTERNAL;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousMode(test.FidlChannel(),
                                                                                 false,
                                                                                 &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, ConfigMulticastTestFilterTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilter(test.FidlChannel(),
                                                                         &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, DumpRegistersTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceDumpRegisters(test.FidlChannel(), &out_status));
     ASSERT_OK(out_status);
     EXPECT_TRUE(test.tester.ethmac().TestDump());
 }

 TEST(EthernetTest, SetIOBufferTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;
     EXPECT_TRUE(fuchsia_hardware_ethernet_DeviceSetIOBuffer(test.FidlChannel(),
                                                             ZX_HANDLE_INVALID,
                                                             &out_status) != ZX_OK);
     EXPECT_TRUE(out_status != ZX_OK);
     zx::vmo buf;
     ASSERT_OK(zx::vmo::create(2 * sizeof(ethmac_netbuf_t), ZX_VMO_NON_RESIZABLE, &buf));
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetIOBuffer(test.FidlChannel(),
                                                           buf.get(), &out_status));
     ASSERT_OK(out_status);
 }

 TEST(EthernetTest, StartTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_OK;
     // test bad state
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceStart(test.FidlChannel(), &out_status));
     EXPECT_TRUE(out_status != ZX_OK);

     // test valid case
     test.Start();

     // test client interfaces
     EXPECT_TRUE(test.tester.ethmac().TestIfc());
 }

 TEST(EthernetTest, GetStatusTest) {
     EthernetDeviceTest test;
     uint32_t device_status;

     //start device
     test.Start();

     //set mock ethmac status
     EXPECT_TRUE(test.tester.ethmac().SetStatus(1));

     //verify status
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetStatus(test.FidlChannel(), &device_status));
     EXPECT_TRUE(device_status == 1);
 }

 #if 0
 // TODO(CONN-135)
 TEST(EthernetTest, SendTest) {
     EthernetDeviceTest test;

     //start device
     test.Start();

     //send packet through the fifo
     zx::fifo& tx = test.TransmitFifo();
     eth_fifo_entry_t entry = {
         .offset = 0,
         .length = 1,
         .flags = 0,
         .cookie = 0,
     };
     ASSERT_OK(tx.write(sizeof(entry), &entry, 1, nullptr));

     //wait for packet to be returned
     ASSERT_OK(tx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
     ASSERT_OK(tx.read(sizeof(entry), &entry, 1, nullptr));

     //check mock ethmac if packet was received
     EXPECT_TRUE(test.tester.ethmac().TestQueueTx());
 }


 TEST(EthernetTest, ReceiveTest) {
     EthernetDeviceTest test;

     //start device
     test.Start();

     // Queue buffer to receive fifo
     zx::fifo& rx = test.ReceiveFifo();
     eth_fifo_entry_t entry = {
         .offset = 0,
         .length = 1,
         .flags = 0,
         .cookie = 0,
     };
     ASSERT_OK(rx.write(sizeof(entry), &entry, 1, nullptr));

     //send packet through mock ethmac
     EXPECT_TRUE(test.tester.ethmac().TestRecv());

     //check if packet is received
     ASSERT_OK(rx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
     ASSERT_OK(rx.read(sizeof(entry), &entry, 1, nullptr));
 }

 TEST(EthernetTest, ListenStartTest) {
     EthernetDeviceTest test;
     zx_status_t out_status = ZX_ERR_INTERNAL;

     // start device
     test.Start();

     // Set listen start
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceListenStart(test.FidlChannel(), &out_status));
     ASSERT_OK(out_status);

     // send packet
     eth_fifo_entry_t entry = {
         .offset = 0,
         .length = 1,
         .flags = 0,
         .cookie = 0,
     };
     zx::fifo& tx = test.TransmitFifo();
     ASSERT_OK(tx.write(sizeof(entry), &entry, 1, nullptr));

     zx::fifo& rx = test.ReceiveFifo();
     ASSERT_OK(rx.write(sizeof(entry), &entry, 1, nullptr));

     //wait for the send to complete
     ASSERT_OK(tx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
     ASSERT_OK(tx.read(sizeof(entry), &entry, 1, nullptr));

     // check if it was echoed
     ASSERT_OK(rx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
     ASSERT_OK(rx.read(sizeof(entry), &entry, 1, nullptr));
 }
 #endif

 TEST(EthernetTest, ListenStopTest) {
     EthernetDeviceTest test;
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceListenStop(test.FidlChannel()));
 }

 TEST(EthernetTest, StopTest) {
     EthernetDeviceTest test;
     test.Start();
     ASSERT_OK(fuchsia_hardware_ethernet_DeviceStop(test.FidlChannel()));
 }
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ethernet.h"

	#include <ddk/debug.h>
	#include <ddk/device.h>
	#include <lib/fake_ddk/fake_ddk.h>
	#include <lib/zx/process.h>
	#include <thread>
	#include <zxtest/zxtest.h>

	class FakeEthmacProtocol : public ddk::Device<FakeEthmacProtocol, ddk::GetProtocolable>,
	public ddk::EthmacProtocol<FakeEthmacProtocol, ddk::base_protocol> {
	public:
	FakeEthmacProtocol()
	: ddk::Device<FakeEthmacProtocol, ddk::GetProtocolable>(fake_ddk::kFakeDevice),
	proto_({&ethmac_protocol_ops_, this}) {
	}

	const ethmac_protocol_t* proto() const { return &proto_; }

	void DdkRelease() {}

	zx_status_t EthmacQuery(uint32_t options, ethmac_info_t* info) {
	info->netbuf_size = sizeof(ethmac_netbuf_t);
	info->mtu = 1500;
	memcpy(info->mac, mac_, sizeof(info->mac));
	return ZX_OK;
	}

	void EthmacStop() {}

	zx_status_t EthmacStart(const ethmac_ifc_protocol_t* ifc) {
	client_ = std::make_unique<ddk::EthmacIfcProtocolClient>(ifc);
	return ZX_OK;
	}

	zx_status_t EthmacQueueTx(uint32_t options, ethmac_netbuf_t* netbuf) {
	queue_tx_called_ = true;
	return ZX_OK;
	}

	zx_status_t EthmacSetParam(uint32_t param, int32_t value, const void* data, size_t data_size) {
	if (param == ETHMAC_SETPARAM_DUMP_REGS) {
	dump_called_ = true;
	}
	return ZX_OK;
	}
	void EthmacGetBti(zx::bti* bti) { bti->reset(); }

	bool TestInfo(fuchsia_hardware_ethernet_Info* info) {
	if (memcmp(mac_, info->mac.octets, ETH_MAC_SIZE) \|\| (info->mtu != 1500)) {
	return false;
	}
	return true;
	}

	bool TestDump() { return dump_called_; }

	bool TestIfc() {
	if (!client_)
	return false;
	// Use the provided client to test the ifc client.
	client_->Status(0);
	client_->Recv(nullptr, 0, 0);
	client_->CompleteTx(nullptr, ZX_OK);
	return true;
	}

	bool SetStatus(uint32_t status) {
	if (!client_)
	return false;
	client_->Status(status);
	return true;
	}

	bool TestQueueTx() {
	return queue_tx_called_;
	}

	bool TestRecv() {
	if (!client_) {
	return false;
	}
	uint8_t data = 0xAA;
	client_->Recv(&data, 1, 0);
	return true;
	}

	private:
	ethmac_protocol_t proto_;
	const uint8_t mac_[ETH_MAC_SIZE] = {0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
	fbl::unique_ptr<ddk::EthmacIfcProtocolClient> client_;

	bool dump_called_ = false;
	bool queue_tx_called_ = false;
	};

	class EthernetTester {
	public:
	EthernetTester() {
	fbl::Array<fake_ddk::ProtocolEntry> protocols(new fake_ddk::ProtocolEntry[1], 1);
	protocols[0] = {ZX_PROTOCOL_ETHMAC,
	reinterpret_cast<const fake_ddk::Protocol>(ethmac_.proto())};
	ddk_.SetProtocols(std::move(protocols));
	}

	fake_ddk::Bind& ddk() { return ddk_; }
	FakeEthmacProtocol& ethmac() { return ethmac_; }

	private:
	fake_ddk::Bind ddk_;
	FakeEthmacProtocol ethmac_;
	};

	TEST(EthernetTest, BindTest) {
	EthernetTester tester;
	EXPECT_EQ(eth::EthDev0::EthBind(nullptr, fake_ddk::kFakeParent), ZX_OK, "Bind failed");
	}

	TEST(EthernetTest, DdkLifecycleTest) {
	EthernetTester tester;
	eth::EthDev0* eth(new eth::EthDev0(fake_ddk::kFakeParent));
	EXPECT_EQ(eth->AddDevice(), ZX_OK, "AddDevice Failed");
	eth->DdkUnbind();
	EXPECT_TRUE(tester.ddk().Ok());
	eth->DdkRelease();
	}

	TEST(EthernetTest, OpenTest) {
	EthernetTester tester;
	eth::EthDev0* eth(new eth::EthDev0(fake_ddk::kFakeParent));
	EXPECT_EQ(eth->AddDevice(), ZX_OK, "AddDevice Failed");
	zx_device_t* eth_instance;
	EXPECT_EQ(eth->DdkOpen(&eth_instance, 0), ZX_OK, "Open Failed");
	eth->DdkUnbind();
	eth->DdkRelease();
	}

	class EthernetDeviceTest {
	public:
	EthernetDeviceTest()
	: tester() {

	edev0 = std::make_unique<eth::EthDev0>(fake_ddk::kFakeParent);
	ASSERT_OK(edev0->AddDevice());

	edev = fbl::MakeRefCounted<eth::EthDev>(fake_ddk::kFakeParent, edev0.get());
	zx_device_t* out;
	ASSERT_OK(edev->AddDevice(&out));
	}

	void Start() {
	zx_status_t out_status = ZX_ERR_INTERNAL;
	fuchsia_hardware_ethernet_Fifos fifos = {};
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetFifos(FidlChannel(), &out_status, &fifos));
	tx_fifo_ = zx::fifo(fifos.tx);
	EXPECT_TRUE(tx_fifo_.is_valid());
	rx_fifo_ = zx::fifo(fifos.rx);
	rx_fifo_depth_ = fifos.rx_depth;
	tx_fifo_depth_ = fifos.tx_depth;
	EXPECT_TRUE(rx_fifo_.is_valid());
	ASSERT_OK(zx::vmo::create(2 * sizeof(ethmac_netbuf_t), ZX_VMO_NON_RESIZABLE, &buf_));
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetIOBuffer(FidlChannel(),
	buf_.get(), &out_status));
	ASSERT_OK(out_status);
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceStart(FidlChannel(), &out_status));
	ASSERT_OK(out_status);
	}

	zx_handle_t FidlChannel() { return tester.ddk().FidlClient().get(); }

	zx::fifo& TransmitFifo() { return tx_fifo_; }

	zx::fifo& ReceiveFifo() { return rx_fifo_; }

	EthernetTester tester;
	fbl::unique_ptr<eth::EthDev0> edev0;
	fbl::RefPtr<eth::EthDev> edev;

	private:
	zx::fifo tx_fifo_;
	zx::fifo rx_fifo_;
	uint32_t rx_fifo_depth_;
	uint32_t tx_fifo_depth_;
	zx::vmo buf_;
	};

	TEST(EthernetTest, MultipleOpenTest) {
	EthernetDeviceTest test;
	EXPECT_EQ(test.edev->DdkOpen(nullptr, 0), ZX_OK, "Instance 1 open failed");
	EXPECT_EQ(test.edev->DdkOpen(nullptr, 0), ZX_OK, "Instance 2 open failed");
	EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 0 close failed");
	EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 1 close failed");
	EXPECT_EQ(test.edev->DdkClose(0), ZX_OK, "Instance 2 close failed");
	}

	TEST(EthernetTest, SetClientNameTest) {
	EthernetDeviceTest test;
	zx_status_t call_status = ZX_OK;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetClientName(test.FidlChannel(),
	"ethtest",
	strlen("ethtest"),
	&call_status));
	ASSERT_OK(call_status);
	}

	TEST(EthernetTest, GetInfoTest) {
	EthernetDeviceTest test;
	fuchsia_hardware_ethernet_Info info = {};
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetInfo(test.FidlChannel(),
	&info));
	EXPECT_TRUE(test.tester.ethmac().TestInfo(&info));
	}

	TEST(EthernetTest, GetFifosTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	fuchsia_hardware_ethernet_Fifos fifos = {};

	ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetFifos(test.FidlChannel(), &out_status, &fifos));
	ASSERT_OK(out_status);
	EXPECT_TRUE(fifos.rx != ZX_HANDLE_INVALID);
	EXPECT_TRUE(fifos.tx != ZX_HANDLE_INVALID);
	}

	TEST(EthernetTest, SetPromiscuousModeTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;

	ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetPromiscuousMode(test.FidlChannel(),
	true, &out_status));
	ASSERT_OK(out_status);

	out_status = ZX_ERR_INTERNAL;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetPromiscuousMode(test.FidlChannel(),
	false, &out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, ConfigMulticastAddMacTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	/* 1st bit should be 1 in multicast */
	fuchsia_hardware_ethernet_MacAddress wrong_addr =
	{.octets = {0x00, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastAddMac(test.FidlChannel(),
	&wrong_addr, &out_status));
	ASSERT_OK(!out_status);
	fuchsia_hardware_ethernet_MacAddress right_addr =
	{.octets = {0x01, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastAddMac(test.FidlChannel(),
	&right_addr, &out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, ConfigMulticastDeleteMacTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	fuchsia_hardware_ethernet_MacAddress addr = {.octets = {0xaa, 0xaa, 0xbb, 0xbb, 0xcc, 0xcc}};
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMac(test.FidlChannel(),
	&addr, &out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, ConfigMulticastSetPromiscuousModeTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousMode(test.FidlChannel(),
	true, &out_status));
	ASSERT_OK(out_status);

	out_status = ZX_ERR_INTERNAL;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousMode(test.FidlChannel(),
	false,
	&out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, ConfigMulticastTestFilterTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilter(test.FidlChannel(),
	&out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, DumpRegistersTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceDumpRegisters(test.FidlChannel(), &out_status));
	ASSERT_OK(out_status);
	EXPECT_TRUE(test.tester.ethmac().TestDump());
	}

	TEST(EthernetTest, SetIOBufferTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;
	EXPECT_TRUE(fuchsia_hardware_ethernet_DeviceSetIOBuffer(test.FidlChannel(),
	ZX_HANDLE_INVALID,
	&out_status) != ZX_OK);
	EXPECT_TRUE(out_status != ZX_OK);
	zx::vmo buf;
	ASSERT_OK(zx::vmo::create(2 * sizeof(ethmac_netbuf_t), ZX_VMO_NON_RESIZABLE, &buf));
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceSetIOBuffer(test.FidlChannel(),
	buf.get(), &out_status));
	ASSERT_OK(out_status);
	}

	TEST(EthernetTest, StartTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_OK;
	// test bad state
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceStart(test.FidlChannel(), &out_status));
	EXPECT_TRUE(out_status != ZX_OK);

	// test valid case
	test.Start();

	// test client interfaces
	EXPECT_TRUE(test.tester.ethmac().TestIfc());
	}

	TEST(EthernetTest, GetStatusTest) {
	EthernetDeviceTest test;
	uint32_t device_status;

	//start device
	test.Start();

	//set mock ethmac status
	EXPECT_TRUE(test.tester.ethmac().SetStatus(1));

	//verify status
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetStatus(test.FidlChannel(), &device_status));
	EXPECT_TRUE(device_status == 1);
	}

	#if 0
	// TODO(CONN-135)
	TEST(EthernetTest, SendTest) {
	EthernetDeviceTest test;

	//start device
	test.Start();

	//send packet through the fifo
	zx::fifo& tx = test.TransmitFifo();
	eth_fifo_entry_t entry = {
	.offset = 0,
	.length = 1,
	.flags = 0,
	.cookie = 0,
	};
	ASSERT_OK(tx.write(sizeof(entry), &entry, 1, nullptr));

	//wait for packet to be returned
	ASSERT_OK(tx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
	ASSERT_OK(tx.read(sizeof(entry), &entry, 1, nullptr));

	//check mock ethmac if packet was received
	EXPECT_TRUE(test.tester.ethmac().TestQueueTx());
	}


	TEST(EthernetTest, ReceiveTest) {
	EthernetDeviceTest test;

	//start device
	test.Start();

	// Queue buffer to receive fifo
	zx::fifo& rx = test.ReceiveFifo();
	eth_fifo_entry_t entry = {
	.offset = 0,
	.length = 1,
	.flags = 0,
	.cookie = 0,
	};
	ASSERT_OK(rx.write(sizeof(entry), &entry, 1, nullptr));

	//send packet through mock ethmac
	EXPECT_TRUE(test.tester.ethmac().TestRecv());

	//check if packet is received
	ASSERT_OK(rx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
	ASSERT_OK(rx.read(sizeof(entry), &entry, 1, nullptr));
	}

	TEST(EthernetTest, ListenStartTest) {
	EthernetDeviceTest test;
	zx_status_t out_status = ZX_ERR_INTERNAL;

	// start device
	test.Start();

	// Set listen start
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceListenStart(test.FidlChannel(), &out_status));
	ASSERT_OK(out_status);

	// send packet
	eth_fifo_entry_t entry = {
	.offset = 0,
	.length = 1,
	.flags = 0,
	.cookie = 0,
	};
	zx::fifo& tx = test.TransmitFifo();
	ASSERT_OK(tx.write(sizeof(entry), &entry, 1, nullptr));

	zx::fifo& rx = test.ReceiveFifo();
	ASSERT_OK(rx.write(sizeof(entry), &entry, 1, nullptr));

	//wait for the send to complete
	ASSERT_OK(tx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
	ASSERT_OK(tx.read(sizeof(entry), &entry, 1, nullptr));

	// check if it was echoed
	ASSERT_OK(rx.wait_one(ZX_FIFO_READABLE, zx::time::infinite(), nullptr));
	ASSERT_OK(rx.read(sizeof(entry), &entry, 1, nullptr));
	}
	#endif

	TEST(EthernetTest, ListenStopTest) {
	EthernetDeviceTest test;
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceListenStop(test.FidlChannel()));
	}

	TEST(EthernetTest, StopTest) {
	EthernetDeviceTest test;
	test.Start();
	ASSERT_OK(fuchsia_hardware_ethernet_DeviceStop(test.FidlChannel()));
	}