This is a simple end-to-end test for abstract sockets. It is possible to
implement tests for address bounds, but those require system specific
information and would require exports from `Network.Socket.Types`. As
such a simple end-to-end tests provides a good balance of coverage.

Simple bounds checking may look like:

```
it "can end-to-end with long abstract socket names" $ do
 when isUnixDomainSocketAvailable $ do
     let
	 abstractAddress =
	     toEnum 0:
	     "/haskell/network/long-abstract-" ++
	     replicate 76 'a'
	 clientAct sock = send sock testMsg
	 server (sock, addr) = do
	   recv sock 1024 `shouldReturn` testMsg
	   addr `shouldBe` (SockAddrUnix "")
     unixTestWith abstractAddress (const $ pure ()) clientAct server
it "fails with too long abstract socket names" $ do
 when isUnixDomainSocketAvailable $ do
     let
	 abstractAddress =
	     toEnum 0:
	     "/haskell/network/long-abstract-" ++
	     replicate 77 'a'
	 clientAct _ = pure ()
	 server _ = pure ()
     unixTestWith abstractAddress (const $ pure ()) clientAct server
	 `shouldThrow` anyErrorCall
```

However this hard codes the bounds and would fail when system specific
configuration differs.