         chai.expect(data.datatype).to.equal 'string'
         chai.expect(data.schema).to.equal 'text/plain'
         done()
+        return
       p.handleIP new noflo.IP 'data', 'Hello',
         datatype: 'string'
         schema: 'text/plain'
+      return
+    return
+  return
    it 'should retain the type', ->
      chai.expect(p.getDataType()).to.equal 'string'
      chai.expect(p.getSchema()).to.equal 'text/url'

  describe 'without attached sockets', ->
    p = new noflo.InPort
    it 'should not be attached', ->
      chai.expect(p.isAttached()).to.equal false
      chai.expect(p.listAttached()).to.eql []
    it 'should allow attaching', ->
      chai.expect(p.canAttach()).to.equal true
    it 'should not be connected initially', ->
      chai.expect(p.isConnected()).to.equal false
    it 'should not contain a socket initially', ->
      chai.expect(p.sockets.length).to.equal 0

  describe 'with processing function called with port as context', ->
    it 'should set context to port itself', (done) ->
      s = new noflo.internalSocket.InternalSocket

      p = new noflo.InPort options
      for name, option of options
        chai.expect(p.options[name]).to.equal option
      return
    return
  describe 'with data type information', ->
    right = 'all string number int object array'.split ' '
    wrong = 'not valie data types'.split ' '
    f = (datatype) ->
      return new noflo.InPort
        datatype: datatype
    right.forEach (r) ->
      it "should accept a '#{r}' data type", =>
        chai.expect(-> f r).to.not.throw()
        return
      return
    wrong.forEach (w) ->
      it "should NOT accept a '#{w}' data type", =>
        chai.expect(-> f w).to.throw()
        return
      return
    return
  describe 'with TYPE (i.e. ontology) information', ->
    f = (type) ->
      return new noflo.InPort
        type: type
    it 'should be a URL or MIME', ->
      chai.expect(-> f 'http://schema.org/Person').to.not.throw()
      chai.expect(-> f 'text/javascript').to.not.throw()
      chai.expect(-> f 'neither-a-url-nor-mime').to.throw()
      return
    return
  describe 'with accepted enumerated values', ->
    it 'should accept certain values', (done) ->
      p = new noflo.InPort
