diff --git a/core/deliverservice/blocksprovider/blocksprovider_test.go b/core/deliverservice/blocksprovider/blocksprovider_test.go
index 54d69d23b53..ada21427720 100644
--- a/core/deliverservice/blocksprovider/blocksprovider_test.go
+++ b/core/deliverservice/blocksprovider/blocksprovider_test.go
@@ -16,7 +16,9 @@ limitations under the License.
 package blocksprovider
 
 import (
+	"errors"
 	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -26,16 +28,22 @@ import (
 	"github.com/hyperledger/fabric/protos/common"
 	"github.com/hyperledger/fabric/protos/orderer"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 type mockMCS struct {
+	mock.Mock
 }
 
 func (*mockMCS) GetPKIidOfCert(peerIdentity api.PeerIdentityType) common2.PKIidType {
 	return common2.PKIidType("pkiID")
 }
 
-func (*mockMCS) VerifyBlock(chainID common2.ChainID, signedBlock []byte) error {
+func (m *mockMCS) VerifyBlock(chainID common2.ChainID, signedBlock []byte) error {
+	args := m.Called()
+	if args.Get(0) != nil {
+		return args.Get(0).(error)
+	}
 	return nil
 }
 
@@ -55,21 +63,17 @@ func (*mockMCS) ValidateIdentity(peerIdentity api.PeerIdentityType) error {
 	return nil
 }
 
+type rcvFunc func(mock *mocks.MockBlocksDeliverer) (*orderer.DeliverResponse, error)
+
 // Used to generate a simple test case to initialize delivery
 // from given block sequence number.
-func makeTestCase(ledgerHeight uint64) func(*testing.T) {
+func makeTestCase(ledgerHeight uint64, mcs api.MessageCryptoService, shouldSucceed bool, rcv rcvFunc) func(*testing.T) {
 	return func(t *testing.T) {
 		gossipServiceAdapter := &mocks.MockGossipServiceAdapter{GossipBlockDisseminations: make(chan uint64)}
 		deliverer := &mocks.MockBlocksDeliverer{Pos: ledgerHeight}
-		deliverer.MockRecv = mocks.MockRecv
-
-		provider := &blocksProviderImpl{
-			chainID: "***TEST_CHAINID***",
-			gossip:  gossipServiceAdapter,
-			client:  deliverer,
-			mcs:     &mockMCS{},
-		}
-
+		deliverer.MockRecv = rcv
+		provider := NewBlocksProvider("***TEST_CHAINID***", deliverer, gossipServiceAdapter, mcs)
+		defer provider.Stop()
 		ready := make(chan struct{})
 		go func() {
 			go provider.DeliverBlocks()
@@ -77,25 +81,24 @@ func makeTestCase(ledgerHeight uint64) func(*testing.T) {
 			ready <- struct{}{}
 		}()
 
-		time.Sleep(time.Duration(10) * time.Millisecond)
-		provider.Stop()
-
-		select {
-		case <-ready:
-			{
-				// Check that all blocks received eventually get gossiped and locally committed
-				assert.True(t, deliverer.RecvCnt == gossipServiceAdapter.AddPayloadsCnt)
-				select {
-				case <-gossipServiceAdapter.GossipBlockDisseminations:
-				case <-time.After(time.Second):
-					assert.Fail(t, "Didn't gossip a block within a timely manner")
-				}
-				return
-			}
-		case <-time.After(time.Duration(1) * time.Second):
-			{
-				t.Fatal("Test hasn't finished in timely manner, failing.")
-			}
+		time.Sleep(time.Second)
+
+		assertDelivery(t, gossipServiceAdapter, deliverer, shouldSucceed)
+	}
+}
+
+func assertDelivery(t *testing.T, ga *mocks.MockGossipServiceAdapter, deliverer *mocks.MockBlocksDeliverer, shouldSucceed bool) {
+	// Check that all blocks received eventually get gossiped and locally committed
+
+	select {
+	case <-ga.GossipBlockDisseminations:
+		if !shouldSucceed {
+			assert.Fail(t, "Should not have succeede")
+		}
+		assert.True(t, deliverer.RecvCnt == ga.AddPayloadsCnt)
+	case <-time.After(time.Second):
+		if shouldSucceed {
+			assert.Fail(t, "Didn't gossip a block within a timely manner")
 		}
 	}
 }
@@ -105,7 +108,9 @@ func makeTestCase(ledgerHeight uint64) func(*testing.T) {
    oldest and that eventually it terminates after the Stop method has been called.
 */
 func TestBlocksProviderImpl_GetBlockFromTheOldest(t *testing.T) {
-	makeTestCase(uint64(0))(t)
+	mcs := &mockMCS{}
+	mcs.On("VerifyBlock", mock.Anything).Return(nil)
+	makeTestCase(uint64(0), mcs, true, mocks.MockRecv)(t)
 }
 
 /*
@@ -113,11 +118,12 @@ func TestBlocksProviderImpl_GetBlockFromTheOldest(t *testing.T) {
    oldest and that eventually it terminates after the Stop method has been called.
 */
 func TestBlocksProviderImpl_GetBlockFromSpecified(t *testing.T) {
-	makeTestCase(uint64(101))(t)
+	mcs := &mockMCS{}
+	mcs.On("VerifyBlock", mock.Anything).Return(nil)
+	makeTestCase(uint64(101), mcs, true, mocks.MockRecv)(t)
 }
 
 func TestBlocksProvider_CheckTerminationDeliveryResponseStatus(t *testing.T) {
-
 	tmp := struct{ mocks.MockBlocksDeliverer }{}
 
 	// Making mocked Recv() function to return DeliverResponse_Status to force block
@@ -158,7 +164,7 @@ func TestBlocksProvider_CheckTerminationDeliveryResponseStatus(t *testing.T) {
 			assert.Equal(t, int32(1), tmp.RecvCnt)
 			// No payload should commit locally
 			assert.Equal(t, int32(0), gossipServiceAdapter.AddPayloadsCnt)
-			// No payload should be transfered to other peers
+			// No payload should be transferred to other peers
 			select {
 			case <-gossipServiceAdapter.GossipBlockDisseminations:
 				assert.Fail(t, "Gossiped block but shouldn't have")
@@ -172,3 +178,42 @@ func TestBlocksProvider_CheckTerminationDeliveryResponseStatus(t *testing.T) {
 		}
 	}
 }
+
+func TestBlockFetchFailure(t *testing.T) {
+	rcvr := func(mock *mocks.MockBlocksDeliverer) (*orderer.DeliverResponse, error) {
+		return nil, errors.New("Failed fetching block")
+	}
+	mcs := &mockMCS{}
+	mcs.On("VerifyBlock", mock.Anything).Return(nil)
+	makeTestCase(uint64(0), mcs, false, rcvr)(t)
+}
+
+func TestBlockVerificationFailure(t *testing.T) {
+	attempts := int32(0)
+	rcvr := func(mock *mocks.MockBlocksDeliverer) (*orderer.DeliverResponse, error) {
+		if atomic.LoadInt32(&attempts) == int32(1) {
+			return &orderer.DeliverResponse{
+				Type: &orderer.DeliverResponse_Status{
+					Status: common.Status_SUCCESS,
+				},
+			}, nil
+		}
+		atomic.AddInt32(&attempts, int32(1))
+		return &orderer.DeliverResponse{
+			Type: &orderer.DeliverResponse_Block{
+				Block: &common.Block{
+					Header: &common.BlockHeader{
+						Number:       0,
+						DataHash:     []byte{},
+						PreviousHash: []byte{},
+					},
+					Data: &common.BlockData{
+						Data: [][]byte{},
+					},
+				}},
+		}, nil
+	}
+	mcs := &mockMCS{}
+	mcs.On("VerifyBlock", mock.Anything).Return(errors.New("Invalid signature"))
+	makeTestCase(uint64(0), mcs, false, rcvr)(t)
+}
diff --git a/core/deliverservice/mocks/blocksprovider.go b/core/deliverservice/mocks/blocksprovider.go
index d9deda55cff..39a7ef67146 100644
--- a/core/deliverservice/mocks/blocksprovider.go
+++ b/core/deliverservice/mocks/blocksprovider.go
@@ -114,13 +114,9 @@ func (mock *MockBlocksDeliverer) Send(env *common.Envelope) error {
 	// Read starting position
 	switch t := seekInfo.Start.Type.(type) {
 	case *orderer.SeekPosition_Oldest:
-		{
-			mock.Pos = 0
-		}
+		mock.Pos = 0
 	case *orderer.SeekPosition_Specified:
-		{
-			mock.Pos = t.Specified.Number
-		}
+		mock.Pos = t.Specified.Number
 	}
 	return nil
 }
diff --git a/core/deliverservice/mocks/blocksprovider_test.go b/core/deliverservice/mocks/blocksprovider_test.go
index cc737db01f3..97d71350a1b 100644
--- a/core/deliverservice/mocks/blocksprovider_test.go
+++ b/core/deliverservice/mocks/blocksprovider_test.go
@@ -17,26 +17,114 @@ limitations under the License.
 package mocks
 
 import (
+	"context"
+	"math"
+	"sync/atomic"
 	"testing"
+	"time"
 
+	pb "github.com/golang/protobuf/proto"
 	"github.com/hyperledger/fabric/core/deliverservice/blocksprovider"
+	"github.com/hyperledger/fabric/protos/common"
+	proto "github.com/hyperledger/fabric/protos/gossip"
+	"github.com/hyperledger/fabric/protos/orderer"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMockBlocksDeliverer(t *testing.T) {
+	// Make sure it implements BlocksDeliverer
 	var bd blocksprovider.BlocksDeliverer
 	bd = &MockBlocksDeliverer{}
 	_ = bd
+
+	assert.Panics(t, func() {
+		bd.Recv()
+	})
+	bd.(*MockBlocksDeliverer).MockRecv = func(mock *MockBlocksDeliverer) (*orderer.DeliverResponse, error) {
+		return &orderer.DeliverResponse{
+			Type: &orderer.DeliverResponse_Status{
+				Status: common.Status_FORBIDDEN,
+			},
+		}, nil
+	}
+	status, err := bd.Recv()
+	assert.Nil(t, err)
+	assert.Equal(t, common.Status_FORBIDDEN, status.GetStatus())
+	bd.(*MockBlocksDeliverer).MockRecv = MockRecv
+	block, err := bd.Recv()
+	assert.Nil(t, err)
+	assert.Equal(t, uint64(0), block.GetBlock().Header.Number)
+
+	bd.(*MockBlocksDeliverer).Close()
+
+	seekInfo := &orderer.SeekInfo{
+		Start:    &orderer.SeekPosition{Type: &orderer.SeekPosition_Oldest{Oldest: &orderer.SeekOldest{}}},
+		Stop:     &orderer.SeekPosition{Type: &orderer.SeekPosition_Specified{Specified: &orderer.SeekSpecified{Number: math.MaxUint64}}},
+		Behavior: orderer.SeekInfo_BLOCK_UNTIL_READY,
+	}
+	si, err := pb.Marshal(seekInfo)
+	assert.NoError(t, err)
+
+	payload := &common.Payload{}
+
+	payload.Data = si
+	b, err := pb.Marshal(payload)
+	assert.NoError(t, err)
+	assert.Nil(t, bd.Send(&common.Envelope{Payload: b}))
 }
 
 func TestMockGossipServiceAdapter(t *testing.T) {
+	// Make sure it implements GossipServiceAdapter
 	var gsa blocksprovider.GossipServiceAdapter
-	gsa = &MockGossipServiceAdapter{}
+	seqNums := make(chan uint64, 1)
+	gsa = &MockGossipServiceAdapter{GossipBlockDisseminations: seqNums}
 	_ = gsa
 
+	// Test gossip
+	msg := &proto.GossipMessage{
+		Content: &proto.GossipMessage_DataMsg{
+			DataMsg: &proto.DataMessage{
+				Payload: &proto.Payload{
+					SeqNum: uint64(100),
+				},
+			},
+		},
+	}
+	gsa.Gossip(msg)
+	select {
+	case seq := <-seqNums:
+		assert.Equal(t, uint64(100), seq)
+	case <-time.After(time.Second):
+		assert.Fail(t, "Didn't gossip within a timely manner")
+	}
+
+	// Test AddPayload
+	gsa.AddPayload("TEST", msg.GetDataMsg().Payload)
+	assert.Equal(t, int32(1), atomic.LoadInt32(&(gsa.(*MockGossipServiceAdapter).AddPayloadsCnt)))
+
+	// Test PeersOfChannel
+	assert.Len(t, gsa.PeersOfChannel(nil), 0)
+}
+
+func TestMockAtomicBroadcastClient(t *testing.T) {
+	// Make sure it implements MockAtomicBroadcastClient
+	var abc orderer.AtomicBroadcastClient
+	abc = &MockAtomicBroadcastClient{BD: &MockBlocksDeliverer{}}
+
+	assert.Panics(t, func() {
+		abc.Broadcast(context.Background())
+	})
+	c, err := abc.Deliver(context.Background())
+	assert.Nil(t, err)
+	assert.NotNil(t, c)
 }
 
 func TestMockLedgerInfo(t *testing.T) {
 	var li blocksprovider.LedgerInfo
-	li = &MockLedgerInfo{}
+	li = &MockLedgerInfo{uint64(8)}
 	_ = li
+
+	height, err := li.LedgerHeight()
+	assert.Equal(t, uint64(8), height)
+	assert.NoError(t, err)
 }
diff --git a/core/deliverservice/mocks/orderer.go b/core/deliverservice/mocks/orderer.go
index d05ea2d258a..a4915e3f5e5 100644
--- a/core/deliverservice/mocks/orderer.go
+++ b/core/deliverservice/mocks/orderer.go
@@ -77,7 +77,6 @@ func (o *Orderer) SendBlock(seq uint64) {
 func (o *Orderer) Deliver(stream orderer.AtomicBroadcast_DeliverServer) error {
 	envlp, err := stream.Recv()
 	if err != nil {
-		fmt.Println(err)
 		return nil
 	}
 	payload := &common.Payload{}
diff --git a/core/deliverservice/mocks/orderer_test.go b/core/deliverservice/mocks/orderer_test.go
new file mode 100644
index 00000000000..acfd4152777
--- /dev/null
+++ b/core/deliverservice/mocks/orderer_test.go
@@ -0,0 +1,69 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mocks
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	pb "github.com/golang/protobuf/proto"
+	"github.com/hyperledger/fabric/protos/common"
+	"github.com/hyperledger/fabric/protos/orderer"
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+)
+
+type clStream struct {
+	grpc.ServerStream
+}
+
+func (cs *clStream) Send(*orderer.DeliverResponse) error {
+	return nil
+}
+func (cs *clStream) Recv() (*common.Envelope, error) {
+	seekInfo := &orderer.SeekInfo{
+		Start:    &orderer.SeekPosition{Type: &orderer.SeekPosition_Specified{Specified: &orderer.SeekSpecified{Number: 0}}},
+		Stop:     &orderer.SeekPosition{Type: &orderer.SeekPosition_Specified{Specified: &orderer.SeekSpecified{Number: math.MaxUint64}}},
+		Behavior: orderer.SeekInfo_BLOCK_UNTIL_READY,
+	}
+	si, _ := pb.Marshal(seekInfo)
+	payload := &common.Payload{}
+	payload.Data = si
+	b, err := pb.Marshal(payload)
+	if err != nil {
+		panic(err)
+	}
+	e := &common.Envelope{Payload: b}
+	return e, nil
+}
+
+func TestOrderer(t *testing.T) {
+	o := NewOrderer(8000, t)
+
+	go func() {
+		time.Sleep(time.Second)
+		o.SendBlock(uint64(0))
+		o.Shutdown()
+	}()
+
+	assert.Panics(t, func() {
+		o.Broadcast(nil)
+	})
+	o.SetNextExpectedSeek(uint64(0))
+	o.Deliver(&clStream{})
+}
diff --git a/gossip/api/api_test.go b/gossip/api/api_test.go
new file mode 100644
index 00000000000..6279bcc4c8b
--- /dev/null
+++ b/gossip/api/api_test.go
@@ -0,0 +1,23 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package api
+
+import "testing"
+
+func TestNoop(t *testing.T) {
+	// This is just to make this package included in the code-coverage statistics
+}
diff --git a/gossip/api/channel.go b/gossip/api/channel.go
index b95a758ac7b..377ad41f035 100644
--- a/gossip/api/channel.go
+++ b/gossip/api/channel.go
@@ -20,6 +20,14 @@ import (
 	"github.com/hyperledger/fabric/gossip/common"
 )
 
+func init() {
+	// This is just to satisfy the code coverage tool
+	// miss any methods
+	switch true {
+
+	}
+}
+
 // SecurityAdvisor defines an external auxiliary object
 // that provides security and identity related capabilities
 type SecurityAdvisor interface {
diff --git a/gossip/comm/comm_test.go b/gossip/comm/comm_test.go
index 25cfaf131a7..bd4573792f8 100644
--- a/gossip/comm/comm_test.go
+++ b/gossip/comm/comm_test.go
@@ -259,13 +259,14 @@ func TestHandshake(t *testing.T) {
 	case <-time.After(time.Second * 10):
 		assert.Fail(t, "skipHandshake flag should have authorized the authentication")
 	}
-
 }
 
 func TestBasic(t *testing.T) {
 	t.Parallel()
 	comm1, _ := newCommInstance(2000, naiveSec)
 	comm2, _ := newCommInstance(3000, naiveSec)
+	comm1.(*commImpl).SetDialOpts()
+	comm2.(*commImpl).SetDialOpts()
 	defer comm1.Stop()
 	defer comm2.Stop()
 	m1 := comm1.Accept(acceptAll)
@@ -283,6 +284,49 @@ func TestBasic(t *testing.T) {
 	waitForMessages(t, out, 2, "Didn't receive 2 messages")
 }
 
+func TestProdConstructor(t *testing.T) {
+	t.Parallel()
+	keyFileName := fmt.Sprintf("key.%d.pem", util.RandomUInt64())
+	certFileName := fmt.Sprintf("cert.%d.pem", util.RandomUInt64())
+
+	generateCertificates(keyFileName, certFileName)
+	cert, _ := tls.LoadX509KeyPair(certFileName, keyFileName)
+	os.Remove(keyFileName)
+	os.Remove(certFileName)
+	srv, lsnr, dialOpts, certHash := createGRPCLayer(20000)
+	defer srv.Stop()
+	defer lsnr.Close()
+	comm1, _ := NewCommInstance(srv, &cert, identity.NewIdentityMapper(naiveSec), []byte("localhost:20000"), dialOpts)
+	comm1.(*commImpl).selfCertHash = certHash
+	go srv.Serve(lsnr)
+
+	generateCertificates(keyFileName, certFileName)
+	cert, _ = tls.LoadX509KeyPair(certFileName, keyFileName)
+	os.Remove(keyFileName)
+	os.Remove(certFileName)
+	srv, lsnr, dialOpts, certHash = createGRPCLayer(30000)
+	defer srv.Stop()
+	defer lsnr.Close()
+	comm2, _ := NewCommInstance(srv, &cert, identity.NewIdentityMapper(naiveSec), []byte("localhost:30000"), dialOpts)
+	comm2.(*commImpl).selfCertHash = certHash
+	go srv.Serve(lsnr)
+	defer comm1.Stop()
+	defer comm2.Stop()
+	m1 := comm1.Accept(acceptAll)
+	m2 := comm2.Accept(acceptAll)
+	out := make(chan uint64, 2)
+	reader := func(ch <-chan proto.ReceivedMessage) {
+		m := <-ch
+		out <- m.GetGossipMessage().Nonce
+	}
+	go reader(m1)
+	go reader(m2)
+	comm1.Send(createGossipMsg(), remotePeer(30000))
+	time.Sleep(time.Second)
+	comm2.Send(createGossipMsg(), remotePeer(20000))
+	waitForMessages(t, out, 2, "Didn't receive 2 messages")
+}
+
 func TestGetConnectionInfo(t *testing.T) {
 	t.Parallel()
 	comm1, _ := newCommInstance(6000, naiveSec)
@@ -296,6 +340,7 @@ func TestGetConnectionInfo(t *testing.T) {
 		t.Fatal("Didn't receive a message in time")
 	case msg := <-m1:
 		assert.Equal(t, comm2.GetPKIid(), msg.GetConnectionInfo().ID)
+		assert.NotNil(t, msg.GetSourceEnvelope())
 	}
 }
 
diff --git a/gossip/comm/crypto_test.go b/gossip/comm/crypto_test.go
index a053369773e..873bb6ca147 100644
--- a/gossip/comm/crypto_test.go
+++ b/gossip/comm/crypto_test.go
@@ -105,7 +105,10 @@ func TestCertificateExtraction(t *testing.T) {
 		InsecureSkipVerify: true,
 	})
 	assert.NoError(t, err, "%v", err)
-	conn, err := grpc.Dial("localhost:5611", grpc.WithTransportCredentials(&authCreds{tlsCreds: ta}), grpc.WithBlock(), grpc.WithTimeout(time.Second))
+	ac := &authCreds{tlsCreds: ta}
+	assert.Equal(t, "1.2", ac.Info().SecurityVersion)
+	assert.Equal(t, "tls", ac.Info().SecurityProtocol)
+	conn, err := grpc.Dial("localhost:5611", grpc.WithTransportCredentials(ac), grpc.WithBlock(), grpc.WithTimeout(time.Second))
 	assert.NoError(t, err, "%v", err)
 
 	cl := proto.NewGossipClient(conn)
diff --git a/gossip/comm/demux_test.go b/gossip/comm/demux_test.go
new file mode 100644
index 00000000000..896ff571fa9
--- /dev/null
+++ b/gossip/comm/demux_test.go
@@ -0,0 +1,25 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+		 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package comm
+
+import "testing"
+
+func TestChannelDeMultiplexer_Close(t *testing.T) {
+	demux := NewChannelDemultiplexer()
+	demux.Close()
+	demux.DeMultiplex("msg")
+}
diff --git a/gossip/comm/mock/mock_comm.go b/gossip/comm/mock/mock_comm.go
index 048775efe12..c1467efff69 100644
--- a/gossip/comm/mock/mock_comm.go
+++ b/gossip/comm/mock/mock_comm.go
@@ -192,8 +192,3 @@ func (mock *commMock) Stop() {
 	logger.Debug("[XXX]: Sending done signal to close the module.")
 	mock.done <- struct{}{}
 }
-
-// BlackListPKIid prohibits the module communicating with the given PKIid
-func (mock *commMock) BlackListPKIid(PKIid common.PKIidType) {
-	// NOOP
-}
diff --git a/gossip/comm/mock/mock_comm_test.go b/gossip/comm/mock/mock_comm_test.go
index cfa8edda9dd..450ad07153d 100644
--- a/gossip/comm/mock/mock_comm_test.go
+++ b/gossip/comm/mock/mock_comm_test.go
@@ -54,6 +54,7 @@ func TestMockComm(t *testing.T) {
 	msg := <-msgCh
 
 	assert.NotNil(t, msg.GetGossipMessage().GetStateRequest())
+	assert.Equal(t, "first", string(comm1.GetPKIid()))
 }
 
 func TestMockComm_PingPong(t *testing.T) {
diff --git a/gossip/common/common.go b/gossip/common/common.go
index 245814db8c6..7884bc1a35a 100644
--- a/gossip/common/common.go
+++ b/gossip/common/common.go
@@ -16,6 +16,14 @@ limitations under the License.
 
 package common
 
+func init() {
+	// This is just to satisfy the code coverage tool
+	// miss any methods
+	switch true {
+
+	}
+}
+
 // PKIidType defines the type that holds the PKI-id
 // which is the security identifier of a peer
 type PKIidType []byte
diff --git a/gossip/common/common_test.go b/gossip/common/common_test.go
new file mode 100644
index 00000000000..43d123576c7
--- /dev/null
+++ b/gossip/common/common_test.go
@@ -0,0 +1,23 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package common
+
+import "testing"
+
+func TestNoop(t *testing.T) {
+	// This is just to make this package included in the code-coverage statistics
+}
diff --git a/gossip/discovery/discovery_impl.go b/gossip/discovery/discovery_impl.go
index 4a2f2083137..723efafd05d 100644
--- a/gossip/discovery/discovery_impl.go
+++ b/gossip/discovery/discovery_impl.go
@@ -19,13 +19,12 @@ package discovery
 import (
 	"bytes"
 	"fmt"
+	"strconv"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"strconv"
-	"strings"
-
 	"github.com/hyperledger/fabric/gossip/common"
 	"github.com/hyperledger/fabric/gossip/gossip/msgstore"
 	"github.com/hyperledger/fabric/gossip/util"
@@ -618,17 +617,6 @@ func (d *gossipDiscoveryImpl) createMembershipRequest(includeInternalEndpoint bo
 	}).NoopSign()
 }
 
-func (d *gossipDiscoveryImpl) getKnownPeers() [][]byte {
-	d.lock.RLock()
-	defer d.lock.RUnlock()
-
-	peers := [][]byte{}
-	for id := range d.id2Member {
-		peers = append(peers, common.PKIidType(id))
-	}
-	return peers
-}
-
 func (d *gossipDiscoveryImpl) copyLastSeen(lastSeenMap map[string]*timestamp) []NetworkMember {
 	d.lock.RLock()
 	defer d.lock.RUnlock()
diff --git a/gossip/discovery/discovery_test.go b/gossip/discovery/discovery_test.go
index 40d7c49d816..a5b235f56ed 100644
--- a/gossip/discovery/discovery_test.go
+++ b/gossip/discovery/discovery_test.go
@@ -330,6 +330,35 @@ func bootPeer(port int) string {
 	return fmt.Sprintf("localhost:%d", port)
 }
 
+func TestToString(t *testing.T) {
+	nm := NetworkMember{
+		Endpoint:         "a",
+		InternalEndpoint: "b",
+	}
+	assert.Equal(t, "b", nm.PreferredEndpoint())
+	nm = NetworkMember{
+		Endpoint: "a",
+	}
+	assert.Equal(t, "a", nm.PreferredEndpoint())
+
+	now := time.Now()
+	ts := &timestamp{
+		incTime: now,
+		seqNum:  uint64(42),
+	}
+	assert.Equal(t, fmt.Sprintf("%d, %d", now.UnixNano(), 42), fmt.Sprint(ts))
+}
+
+func TestBadInput(t *testing.T) {
+	inst := createDiscoveryInstance(2048, fmt.Sprintf("d%d", 0), []string{})
+	inst.Discovery.(*gossipDiscoveryImpl).handleMsgFromComm(nil)
+	inst.Discovery.(*gossipDiscoveryImpl).handleMsgFromComm((&proto.GossipMessage{
+		Content: &proto.GossipMessage_DataMsg{
+			DataMsg: &proto.DataMessage{},
+		},
+	}).NoopSign())
+}
+
 func TestConnect(t *testing.T) {
 	t.Parallel()
 	nodeNum := 10
diff --git a/gossip/filter/filter_test.go b/gossip/filter/filter_test.go
new file mode 100644
index 00000000000..6036e204288
--- /dev/null
+++ b/gossip/filter/filter_test.go
@@ -0,0 +1,73 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package filter
+
+import (
+	"testing"
+
+	"github.com/hyperledger/fabric/gossip/common"
+	"github.com/hyperledger/fabric/gossip/discovery"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSelectPolicies(t *testing.T) {
+	assert.True(t, SelectAllPolicy(discovery.NetworkMember{}))
+	assert.False(t, SelectNonePolicy(discovery.NetworkMember{}))
+}
+
+func TestCombineRoutingFilters(t *testing.T) {
+	nm := discovery.NetworkMember{
+		Endpoint:         "a",
+		InternalEndpoint: "b",
+	}
+	// Ensure that combine routing filter is a logical AND
+	a := func(nm discovery.NetworkMember) bool {
+		return nm.Endpoint == "a"
+	}
+	b := func(nm discovery.NetworkMember) bool {
+		return nm.InternalEndpoint == "b"
+	}
+	assert.True(t, CombineRoutingFilters(a, b)(nm))
+	assert.False(t, CombineRoutingFilters(CombineRoutingFilters(a, b), SelectNonePolicy)(nm))
+	assert.False(t, CombineRoutingFilters(a, b)(discovery.NetworkMember{InternalEndpoint: "b"}))
+}
+
+func TestSelectPeers(t *testing.T) {
+	a := func(nm discovery.NetworkMember) bool {
+		return nm.Endpoint == "a"
+	}
+	b := func(nm discovery.NetworkMember) bool {
+		return nm.InternalEndpoint == "b"
+	}
+	nm1 := discovery.NetworkMember{
+		Endpoint:         "a",
+		InternalEndpoint: "b",
+		PKIid:            common.PKIidType("a"),
+	}
+	nm2 := discovery.NetworkMember{
+		Endpoint:         "a",
+		InternalEndpoint: "b",
+		PKIid:            common.PKIidType("b"),
+	}
+	nm3 := discovery.NetworkMember{
+		Endpoint:         "d",
+		InternalEndpoint: "b",
+		PKIid:            common.PKIidType("c"),
+	}
+	assert.Len(t, SelectPeers(3, []discovery.NetworkMember{nm1, nm2, nm3}, CombineRoutingFilters(a, b)), 2)
+	assert.Len(t, SelectPeers(1, []discovery.NetworkMember{nm1, nm2, nm3}, CombineRoutingFilters(a, b)), 1)
+}
diff --git a/gossip/integration/integration_test.go b/gossip/integration/integration_test.go
index 029070aecb9..7f3d28e130e 100644
--- a/gossip/integration/integration_test.go
+++ b/gossip/integration/integration_test.go
@@ -21,7 +21,6 @@ import (
 	"net"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/hyperledger/fabric/core/config"
 	"github.com/hyperledger/fabric/gossip/api"
@@ -31,6 +30,7 @@ import (
 	"github.com/hyperledger/fabric/msp/mgmt"
 	"github.com/hyperledger/fabric/msp/mgmt/testtools"
 	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
 	"google.golang.org/grpc"
 )
 
@@ -38,41 +38,50 @@ func init() {
 	util.SetupTestLogging()
 }
 
+var (
+	cryptSvc = &cryptoService{}
+	secAdv   = &secAdviser{}
+)
+
 // This is just a test that shows how to instantiate a gossip component
 func TestNewGossipCryptoService(t *testing.T) {
 	setupTestEnv()
 	s1 := grpc.NewServer()
 	s2 := grpc.NewServer()
 	s3 := grpc.NewServer()
-
 	ll1, _ := net.Listen("tcp", fmt.Sprintf("%s:%d", "", 5611))
 	ll2, _ := net.Listen("tcp", fmt.Sprintf("%s:%d", "", 5612))
 	ll3, _ := net.Listen("tcp", fmt.Sprintf("%s:%d", "", 5613))
-
 	endpoint1 := "localhost:5611"
 	endpoint2 := "localhost:5612"
 	endpoint3 := "localhost:5613"
-
 	msptesttools.LoadMSPSetupForTesting()
 	peerIdentity, _ := mgmt.GetLocalSigningIdentityOrPanic().Serialize()
-
-	cryptSvc := &cryptoService{}
-	secAdv := &secAdviser{}
-
 	idMapper := identity.NewIdentityMapper(cryptSvc)
 
 	g1 := NewGossipComponent(peerIdentity, endpoint1, s1, secAdv, cryptSvc, idMapper, []grpc.DialOption{grpc.WithInsecure()})
 	g2 := NewGossipComponent(peerIdentity, endpoint2, s2, secAdv, cryptSvc, idMapper, []grpc.DialOption{grpc.WithInsecure()}, endpoint1)
 	g3 := NewGossipComponent(peerIdentity, endpoint3, s3, secAdv, cryptSvc, idMapper, []grpc.DialOption{grpc.WithInsecure()}, endpoint1)
+	defer g1.Stop()
+	defer g2.Stop()
+	defer g3.Stop()
 	go s1.Serve(ll1)
 	go s2.Serve(ll2)
 	go s3.Serve(ll3)
+}
 
-	time.Sleep(time.Second * 5)
-	fmt.Println(g1.Peers())
-	fmt.Println(g2.Peers())
-	fmt.Println(g3.Peers())
-	time.Sleep(time.Second)
+func TestBadInitialization(t *testing.T) {
+	msptesttools.LoadMSPSetupForTesting()
+	peerIdentity, _ := mgmt.GetLocalSigningIdentityOrPanic().Serialize()
+	s1 := grpc.NewServer()
+	idMapper := identity.NewIdentityMapper(cryptSvc)
+	assert.Panics(t, func() {
+		newConfig("anEndpointWithoutAPort", "anEndpointWithoutAPort")
+	})
+	assert.Panics(t, func() {
+		viper.Set("peer.tls.enabled", true)
+		NewGossipComponent(peerIdentity, "localhost:5000", s1, secAdv, cryptSvc, idMapper, []grpc.DialOption{grpc.WithInsecure()})
+	})
 }
 
 func setupTestEnv() {
diff --git a/gossip/service/eventer_test.go b/gossip/service/eventer_test.go
index 7e06fb82bd1..57e1a9db489 100644
--- a/gossip/service/eventer_test.go
+++ b/gossip/service/eventer_test.go
@@ -38,7 +38,7 @@ func (ao applicationOrgs) AnchorPeers() []*peer.AnchorPeer {
 }
 
 func (ao applicationOrgs) MSPID() string {
-	panic("Unimplimented")
+	return "ORG1"
 }
 
 func (ao applicationOrgs) Name() string {
diff --git a/gossip/service/gossip_service_test.go b/gossip/service/gossip_service_test.go
index dbf2bd4148c..b4d3c1b0fc1 100644
--- a/gossip/service/gossip_service_test.go
+++ b/gossip/service/gossip_service_test.go
@@ -24,6 +24,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/hyperledger/fabric/common/config"
 	"github.com/hyperledger/fabric/common/localmsp"
 	"github.com/hyperledger/fabric/core/deliverservice"
 	"github.com/hyperledger/fabric/core/deliverservice/blocksprovider"
@@ -38,6 +39,7 @@ import (
 	"github.com/hyperledger/fabric/msp/mgmt/testtools"
 	"github.com/hyperledger/fabric/peer/gossip/mcs"
 	"github.com/hyperledger/fabric/protos/common"
+	"github.com/hyperledger/fabric/protos/peer"
 	"github.com/op/go-logging"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
@@ -100,14 +102,14 @@ func TestLeaderElectionWithDeliverClient(t *testing.T) {
 	viper.Set("peer.gossip.orgLeader", false)
 
 	n := 10
-	gossips := startPeers(t, n, 10000)
+	gossips := startPeers(t, n, 20000)
 
 	channelName := "chanA"
 	peerIndexes := make([]int, n)
 	for i := 0; i < n; i++ {
 		peerIndexes[i] = i
 	}
-	addPeersToChannel(t, n, 10000, channelName, gossips, peerIndexes)
+	addPeersToChannel(t, n, 20000, channelName, gossips, peerIndexes)
 
 	waitForFullMembership(t, gossips, n, time.Second*20, time.Second*2)
 
@@ -157,7 +159,7 @@ func TestWithStaticDeliverClientLeader(t *testing.T) {
 	viper.Set("peer.gossip.orgLeader", true)
 
 	n := 2
-	gossips := startPeers(t, n, 10000)
+	gossips := startPeers(t, n, 20000)
 
 	channelName := "chanA"
 	peerIndexes := make([]int, n)
@@ -165,7 +167,7 @@ func TestWithStaticDeliverClientLeader(t *testing.T) {
 		peerIndexes[i] = i
 	}
 
-	addPeersToChannel(t, n, 10000, channelName, gossips, peerIndexes)
+	addPeersToChannel(t, n, 20000, channelName, gossips, peerIndexes)
 
 	waitForFullMembership(t, gossips, n, time.Second*30, time.Second*2)
 
@@ -205,7 +207,7 @@ func TestWithStaticDeliverClientNotLeader(t *testing.T) {
 	viper.Set("peer.gossip.orgLeader", false)
 
 	n := 2
-	gossips := startPeers(t, n, 10000)
+	gossips := startPeers(t, n, 20000)
 
 	channelName := "chanA"
 	peerIndexes := make([]int, n)
@@ -213,7 +215,7 @@ func TestWithStaticDeliverClientNotLeader(t *testing.T) {
 		peerIndexes[i] = i
 	}
 
-	addPeersToChannel(t, n, 10000, channelName, gossips, peerIndexes)
+	addPeersToChannel(t, n, 20000, channelName, gossips, peerIndexes)
 
 	waitForFullMembership(t, gossips, n, time.Second*30, time.Second*2)
 
@@ -242,7 +244,7 @@ func TestWithStaticDeliverClientBothStaticAndLeaderElection(t *testing.T) {
 	viper.Set("peer.gossip.orgLeader", true)
 
 	n := 2
-	gossips := startPeers(t, n, 10000)
+	gossips := startPeers(t, n, 20000)
 
 	channelName := "chanA"
 	peerIndexes := make([]int, n)
@@ -250,7 +252,7 @@ func TestWithStaticDeliverClientBothStaticAndLeaderElection(t *testing.T) {
 		peerIndexes[i] = i
 	}
 
-	addPeersToChannel(t, n, 10000, channelName, gossips, peerIndexes)
+	addPeersToChannel(t, n, 20000, channelName, gossips, peerIndexes)
 
 	waitForFullMembership(t, gossips, n, time.Second*30, time.Second*2)
 
@@ -332,7 +334,7 @@ func TestLeaderElectionWithRealGossip(t *testing.T) {
 
 	// Creating gossip service instances for peers
 	n := 10
-	gossips := startPeers(t, n, 10000)
+	gossips := startPeers(t, n, 20000)
 
 	// Joining all peers to first channel
 	channelName := "chanA"
@@ -340,7 +342,7 @@ func TestLeaderElectionWithRealGossip(t *testing.T) {
 	for i := 0; i < n; i++ {
 		peerIndexes[i] = i
 	}
-	addPeersToChannel(t, n, 10000, channelName, gossips, peerIndexes)
+	addPeersToChannel(t, n, 20000, channelName, gossips, peerIndexes)
 
 	waitForFullMembership(t, gossips, n, time.Second*30, time.Second*2)
 
@@ -373,7 +375,7 @@ func TestLeaderElectionWithRealGossip(t *testing.T) {
 	secondChannelPeerIndexes := []int{1, 3, 5, 7}
 	secondChannelName := "chanB"
 	secondChannelServices := make([]*electionService, len(secondChannelPeerIndexes))
-	addPeersToChannel(t, n, 10000, secondChannelName, gossips, secondChannelPeerIndexes)
+	addPeersToChannel(t, n, 20000, secondChannelName, gossips, secondChannelPeerIndexes)
 
 	for idx, i := range secondChannelPeerIndexes {
 		secondChannelServices[idx] = &electionService{nil, false, 0}
@@ -689,3 +691,55 @@ func (*naiveCryptoService) Verify(peerIdentity api.PeerIdentityType, signature,
 }
 
 var orgInChannelA = api.OrgIdentityType("ORG1")
+
+func TestInvalidInitialization(t *testing.T) {
+	// Test whenever gossip service is indeed singleton
+	grpcServer := grpc.NewServer()
+	socket, error := net.Listen("tcp", fmt.Sprintf("%s:%d", "", 7611))
+	assert.NoError(t, error)
+
+	go grpcServer.Serve(socket)
+	defer grpcServer.Stop()
+
+	InitGossipService(api.PeerIdentityType("IDENTITY"), "localhost:7611", grpcServer, &naiveCryptoService{})
+	gService := GetGossipService().(*gossipServiceImpl)
+	defer gService.Stop()
+
+	dc, err := gService.deliveryFactory.Service(gService, []string{}, &naiveCryptoService{})
+	assert.Nil(t, dc)
+	assert.Error(t, err)
+
+	dc, err = gService.deliveryFactory.Service(gService, []string{"localhost:1984"}, &naiveCryptoService{})
+	assert.NotNil(t, dc)
+	assert.NoError(t, err)
+}
+
+func TestChannelConfig(t *testing.T) {
+	// Test whenever gossip service is indeed singleton
+	grpcServer := grpc.NewServer()
+	socket, error := net.Listen("tcp", fmt.Sprintf("%s:%d", "", 6611))
+	assert.NoError(t, error)
+
+	go grpcServer.Serve(socket)
+	defer grpcServer.Stop()
+
+	InitGossipService(api.PeerIdentityType("IDENTITY"), "localhost:6611", grpcServer, &naiveCryptoService{})
+	gService := GetGossipService().(*gossipServiceImpl)
+	defer gService.Stop()
+
+	jcm := &joinChannelMessage{seqNum: 1, members2AnchorPeers: map[string][]api.AnchorPeer{
+		"A": {{Host: "host", Port: 5000}},
+	}}
+
+	assert.Equal(t, uint64(1), jcm.SequenceNumber())
+
+	mc := &mockConfig{
+		sequence: 1,
+		orgs: map[string]config.ApplicationOrg{
+			testOrgID: applicationOrgs([]*peer.AnchorPeer{}),
+		},
+	}
+	gService.JoinChan(jcm, gossipCommon.ChainID("A"))
+	gService.configUpdated(mc)
+	assert.True(t, gService.amIinChannel(string(orgInChannelA), mc))
+}
diff --git a/gossip/state/mocks/gossip.go b/gossip/state/mocks/gossip.go
new file mode 100644
index 00000000000..bb198144b8a
--- /dev/null
+++ b/gossip/state/mocks/gossip.go
@@ -0,0 +1,72 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+		 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mocks
+
+import (
+	"github.com/hyperledger/fabric/gossip/api"
+	"github.com/hyperledger/fabric/gossip/comm"
+	"github.com/hyperledger/fabric/gossip/common"
+	"github.com/hyperledger/fabric/gossip/discovery"
+	proto "github.com/hyperledger/fabric/protos/gossip"
+	"github.com/stretchr/testify/mock"
+)
+
+type GossipMock struct {
+	mock.Mock
+}
+
+func (*GossipMock) SuspectPeers(s api.PeerSuspector) {
+	panic("implement me")
+}
+
+func (*GossipMock) Send(msg *proto.GossipMessage, peers ...*comm.RemotePeer) {
+	panic("implement me")
+}
+
+func (*GossipMock) Peers() []discovery.NetworkMember {
+	panic("implement me")
+}
+
+func (*GossipMock) PeersOfChannel(common.ChainID) []discovery.NetworkMember {
+	return nil
+}
+
+func (*GossipMock) UpdateMetadata(metadata []byte) {
+	panic("implement me")
+}
+
+func (*GossipMock) UpdateChannelMetadata(metadata []byte, chainID common.ChainID) {
+
+}
+
+func (*GossipMock) Gossip(msg *proto.GossipMessage) {
+	panic("implement me")
+}
+
+func (g *GossipMock) Accept(acceptor common.MessageAcceptor, passThrough bool) (<-chan *proto.GossipMessage, <-chan proto.ReceivedMessage) {
+	args := g.Called(acceptor, passThrough)
+	if args.Get(0) == nil {
+		return nil, args.Get(1).(<-chan proto.ReceivedMessage)
+	}
+	return args.Get(0).(<-chan *proto.GossipMessage), nil
+}
+
+func (g *GossipMock) JoinChan(joinMsg api.JoinChannelMessage, chainID common.ChainID) {
+}
+
+func (*GossipMock) Stop() {
+}
diff --git a/gossip/state/mocks/gossip_test.go b/gossip/state/mocks/gossip_test.go
new file mode 100644
index 00000000000..448e81d9a17
--- /dev/null
+++ b/gossip/state/mocks/gossip_test.go
@@ -0,0 +1,64 @@
+/*
+Copyright IBM Corp. 2017 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+		 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package mocks
+
+import (
+	"testing"
+
+	"github.com/hyperledger/fabric/gossip/api"
+	"github.com/hyperledger/fabric/gossip/common"
+	proto "github.com/hyperledger/fabric/protos/gossip"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestGossipMock(t *testing.T) {
+	g := GossipMock{}
+	mkChan := func() <-chan *proto.GossipMessage {
+		c := make(chan *proto.GossipMessage, 1)
+		c <- &proto.GossipMessage{}
+		return c
+	}
+	g.On("Accept", mock.Anything, false).Return(mkChan(), nil)
+	a, b := g.Accept(func(o interface{}) bool {
+		return true
+	}, false)
+	assert.Nil(t, b)
+	assert.NotNil(t, a)
+	assert.Panics(t, func() {
+		g.SuspectPeers(func(identity api.PeerIdentityType) bool { return false })
+	})
+	assert.Panics(t, func() {
+		g.Send(nil, nil)
+	})
+	assert.Panics(t, func() {
+		g.Peers()
+	})
+	assert.Empty(t, g.PeersOfChannel(common.ChainID("A")))
+
+	assert.Panics(t, func() {
+		g.UpdateMetadata([]byte{})
+	})
+	assert.Panics(t, func() {
+		g.Gossip(nil)
+	})
+	assert.NotPanics(t, func() {
+		g.UpdateChannelMetadata([]byte{}, common.ChainID("A"))
+		g.Stop()
+		g.JoinChan(nil, common.ChainID("A"))
+	})
+}
diff --git a/gossip/state/state.go b/gossip/state/state.go
index 982257843ee..25cd6a068ea 100644
--- a/gossip/state/state.go
+++ b/gossip/state/state.go
@@ -296,6 +296,9 @@ func (s *GossipStateProviderImpl) processStateRequests() {
 // Handle state request message, validate batch size, read current leader state to
 // obtain required blocks, build response message and send it back
 func (s *GossipStateProviderImpl) handleStateRequest(msg proto.ReceivedMessage) {
+	if msg == nil {
+		return
+	}
 	request := msg.GetGossipMessage().GetStateRequest()
 
 	batchSize := request.EndSeqNum - request.StartSeqNum
@@ -428,7 +431,6 @@ func (s *GossipStateProviderImpl) deliverPayloads() {
 					logger.Errorf("Error getting block with seqNum = %d due to (%s)...dropping block", payload.SeqNum, err)
 					continue
 				}
-
 				logger.Debug("New block with sequence number ", payload.SeqNum, " transactions num ", len(rawblock.Data.Data))
 				s.commitBlock(rawblock)
 			}
diff --git a/gossip/state/state_test.go b/gossip/state/state_test.go
index 939fea5222d..4ecc0d5712a 100644
--- a/gossip/state/state_test.go
+++ b/gossip/state/state_test.go
@@ -36,11 +36,13 @@ import (
 	"github.com/hyperledger/fabric/gossip/common"
 	"github.com/hyperledger/fabric/gossip/gossip"
 	"github.com/hyperledger/fabric/gossip/identity"
+	"github.com/hyperledger/fabric/gossip/state/mocks"
 	gutil "github.com/hyperledger/fabric/gossip/util"
 	pcomm "github.com/hyperledger/fabric/protos/common"
 	proto "github.com/hyperledger/fabric/protos/gossip"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 var (
@@ -163,6 +165,32 @@ func (node *peerNode) shutdown() {
 	node.g.Stop()
 }
 
+type mockCommitter struct {
+	mock.Mock
+}
+
+func (mc *mockCommitter) Commit(block *pcomm.Block) error {
+	mc.Called(block)
+	return nil
+}
+
+func (mc *mockCommitter) LedgerHeight() (uint64, error) {
+	if mc.Called().Get(1) == nil {
+		return mc.Called().Get(0).(uint64), nil
+	}
+	return mc.Called().Get(0).(uint64), mc.Called().Get(1).(error)
+}
+
+func (mc *mockCommitter) GetBlocks(blockSeqs []uint64) []*pcomm.Block {
+	if mc.Called(blockSeqs).Get(0) == nil {
+		return nil
+	}
+	return mc.Called(blockSeqs).Get(0).([]*pcomm.Block)
+}
+
+func (*mockCommitter) Close() {
+}
+
 // Default configuration to be used for gossip and communication modules
 func newGossipConfig(id int, boot ...int) *gossip.Config {
 	port := id + portPrefix
@@ -199,10 +227,12 @@ func newCommitter(id int) committer.Committer {
 }
 
 // Constructing pseudo peer node, simulating only gossip and state transfer part
-func newPeerNode(config *gossip.Config, committer committer.Committer, acceptor peerIdentityAcceptor) *peerNode {
+func newPeerNodeWithGossip(config *gossip.Config, committer committer.Committer, acceptor peerIdentityAcceptor, g gossip.Gossip) *peerNode {
 	cs := &cryptoServiceMock{acceptor: acceptor}
 	// Gossip component based on configuration provided and communication module
-	g := newGossipInstance(config, &cryptoServiceMock{acceptor: noopPeerIdentityAcceptor})
+	if g == nil {
+		g = newGossipInstance(config, &cryptoServiceMock{acceptor: noopPeerIdentityAcceptor})
+	}
 
 	logger.Debug("Joinning channel", util.GetTestChainID())
 	g.JoinChan(&joinChanMsg{}, common.ChainID(util.GetTestChainID()))
@@ -210,15 +240,122 @@ func newPeerNode(config *gossip.Config, committer committer.Committer, acceptor
 	// Initialize pseudo peer simulator, which has only three
 	// basic parts
 
+	sp := NewGossipStateProvider(util.GetTestChainID(), g, committer, cs)
+	if sp == nil {
+		return nil
+	}
+
 	return &peerNode{
 		port:   config.BindPort,
 		g:      g,
-		s:      NewGossipStateProvider(util.GetTestChainID(), g, committer, cs),
+		s:      sp,
 		commit: committer,
 		cs:     cs,
 	}
 }
 
+// Constructing pseudo peer node, simulating only gossip and state transfer part
+func newPeerNode(config *gossip.Config, committer committer.Committer, acceptor peerIdentityAcceptor) *peerNode {
+	return newPeerNodeWithGossip(config, committer, acceptor, nil)
+}
+
+func TestNilDirectMsg(t *testing.T) {
+	mc := &mockCommitter{}
+	mc.On("LedgerHeight", mock.Anything).Return(uint64(1), nil)
+	g := &mocks.GossipMock{}
+	g.On("Accept", mock.Anything, false).Return(make(<-chan *proto.GossipMessage), nil)
+	g.On("Accept", mock.Anything, true).Return(nil, make(<-chan proto.ReceivedMessage))
+	p := newPeerNodeWithGossip(newGossipConfig(0), mc, noopPeerIdentityAcceptor, g)
+	defer p.shutdown()
+	p.s.(*GossipStateProviderImpl).handleStateRequest(nil)
+	p.s.(*GossipStateProviderImpl).directMessage(nil)
+	req := &comm.ReceivedMessageImpl{
+		SignedGossipMessage: p.s.(*GossipStateProviderImpl).stateRequestMessage(uint64(10), uint64(8)).NoopSign(),
+	}
+	p.s.(*GossipStateProviderImpl).directMessage(req)
+}
+
+func TestFailures(t *testing.T) {
+	mc := &mockCommitter{}
+	mc.On("LedgerHeight", mock.Anything).Return(uint64(0), nil)
+	g := &mocks.GossipMock{}
+	g.On("Accept", mock.Anything, false).Return(make(<-chan *proto.GossipMessage), nil)
+	g.On("Accept", mock.Anything, true).Return(nil, make(<-chan proto.ReceivedMessage))
+	assert.Panics(t, func() {
+		newPeerNodeWithGossip(newGossipConfig(0), mc, noopPeerIdentityAcceptor, g)
+	})
+	// Reprogram mock
+	mc.Mock = mock.Mock{}
+	mc.On("LedgerHeight", mock.Anything).Return(uint64(1), errors.New("Failed accessing ledger"))
+	assert.Nil(t, newPeerNodeWithGossip(newGossipConfig(0), mc, noopPeerIdentityAcceptor, g))
+	// Reprogram mock
+	mc.Mock = mock.Mock{}
+	mc.On("LedgerHeight", mock.Anything).Return(uint64(1), nil)
+	mc.On("GetBlocks", mock.Anything).Return(nil)
+	p := newPeerNodeWithGossip(newGossipConfig(0), mc, noopPeerIdentityAcceptor, g)
+	assert.Nil(t, p.s.GetBlock(uint64(1)))
+}
+
+func TestGossipReception(t *testing.T) {
+	signalChan := make(chan struct{})
+	rawblock := &pcomm.Block{
+		Header: &pcomm.BlockHeader{
+			Number: uint64(1),
+		},
+		Data: &pcomm.BlockData{
+			Data: [][]byte{},
+		},
+	}
+	b, _ := pb.Marshal(rawblock)
+
+	createChan := func(signalChan chan struct{}) <-chan *proto.GossipMessage {
+		c := make(chan *proto.GossipMessage)
+		gMsg := &proto.GossipMessage{
+			Channel: []byte("AAA"),
+			Content: &proto.GossipMessage_DataMsg{
+				DataMsg: &proto.DataMessage{
+					Payload: &proto.Payload{
+						SeqNum: 1,
+						Data:   b,
+					},
+				},
+			},
+		}
+		go func(c chan *proto.GossipMessage) {
+			// Wait for Accept() to be called
+			<-signalChan
+			// Simulate a message reception from the gossip component with an invalid channel
+			c <- gMsg
+			gMsg.Channel = []byte(util.GetTestChainID())
+			// Simulate a message reception from the gossip component
+			c <- gMsg
+		}(c)
+		return c
+	}
+
+	g := &mocks.GossipMock{}
+	rmc := createChan(signalChan)
+	g.On("Accept", mock.Anything, false).Return(rmc, nil).Run(func(_ mock.Arguments) {
+		signalChan <- struct{}{}
+	})
+	g.On("Accept", mock.Anything, true).Return(nil, make(<-chan proto.ReceivedMessage))
+	mc := &mockCommitter{}
+	receivedChan := make(chan struct{})
+	mc.On("Commit", mock.Anything).Run(func(arguments mock.Arguments) {
+		block := arguments.Get(0).(*pcomm.Block)
+		assert.Equal(t, uint64(1), block.Header.Number)
+		receivedChan <- struct{}{}
+	})
+	mc.On("LedgerHeight", mock.Anything).Return(uint64(1), nil)
+	p := newPeerNodeWithGossip(newGossipConfig(0), mc, noopPeerIdentityAcceptor, g)
+	defer p.shutdown()
+	select {
+	case <-receivedChan:
+	case <-time.After(time.Second * 15):
+		assert.Fail(t, "Didn't commit a block within a timely manner")
+	}
+}
+
 func TestAccessControl(t *testing.T) {
 	viper.Set("peer.fileSystemPath", "/tmp/tests/ledger/node")
 	ledgermgmt.InitializeTestEnv()
diff --git a/gossip/util/misc_test.go b/gossip/util/misc_test.go
index 828a5001923..fd91b03d573 100644
--- a/gossip/util/misc_test.go
+++ b/gossip/util/misc_test.go
@@ -21,6 +21,9 @@ import (
 	"errors"
 	"testing"
 
+	"time"
+
+	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
@@ -78,3 +81,50 @@ func TestGetRandomIntNoEntropy(t *testing.T) {
 	// Make sure randomness still works even when we have no entropy
 	testHappyPath(t)
 }
+
+func TestRandomIndices(t *testing.T) {
+	assert.Nil(t, GetRandomIndices(10, 5))
+	GetRandomIndices(10, 9)
+	GetRandomIndices(10, 12)
+}
+
+func TestGetIntOrDefault(t *testing.T) {
+	viper.Set("N", 100)
+	n := GetIntOrDefault("N", 100)
+	assert.Equal(t, 100, n)
+	m := GetIntOrDefault("M", 101)
+	assert.Equal(t, 101, m)
+}
+
+func TestGetDurationOrDefault(t *testing.T) {
+	viper.Set("foo", time.Second)
+	foo := GetDurationOrDefault("foo", time.Second*2)
+	assert.Equal(t, time.Second, foo)
+	bar := GetDurationOrDefault("bar", time.Second*2)
+	assert.Equal(t, time.Second*2, bar)
+}
+
+func TestPrintStackTrace(t *testing.T) {
+	PrintStackTrace()
+}
+
+func TestGetLogger(t *testing.T) {
+	l1 := GetLogger("foo", "bar")
+	l2 := GetLogger("foo", "bar")
+	assert.Equal(t, l1, l2)
+}
+
+func TestSet(t *testing.T) {
+	s := NewSet()
+	assert.Len(t, s.ToArray(), 0)
+	assert.False(t, s.Exists(42))
+	s.Add(42)
+	assert.True(t, s.Exists(42))
+	assert.Len(t, s.ToArray(), 1)
+	s.Remove(42)
+	assert.False(t, s.Exists(42))
+	s.Add(42)
+	assert.True(t, s.Exists(42))
+	s.Clear()
+	assert.False(t, s.Exists(42))
+}