/ var / www / html / events / node_modules / from / test / [ HOME SHELL ]

Name	Size	Permission	Action
index.js	3.79 KB	-rw-rw-r--

Code Editor : index.js

var from = require('..')
var spec = require('stream-spec')
var a = require('assertions')

function read(stream, callback) {
  var actual = []
  stream.on('data', function (data) {
    actual.push(data)
  })
  stream.once('end', function () {
    callback(null, actual)
  })
  stream.once('error', function (err) {
    callback(err)
  })
}

function pause(stream) {
  stream.on('data', function () {
    if(Math.random() > 0.1) return
    stream.pause()
    process.nextTick(function () {
      stream.resume()
    })
  })
}

exports['inc'] = function (test) {

var fs = from(function (i) {
    this.emit('data', i)
    if(i >= 99)
      return this.emit('end')
    return true
  })

spec(fs).readable().validateOnExit()

read(fs, function (err, arr) {
    test.equal(arr.length, 100)
    test.done()
  })
}

exports['inc - async'] = function (test) {

var fs = from(function (i, next) {
    this.emit('data', i)
    if(i >= 99)
      return this.emit('end')
		next();
  })

spec(fs).readable().validateOnExit()

read(fs, function (err, arr) {
    test.equal(arr.length, 100)
    test.done()
  })
}

exports['large stream - from an array'] = function (test) {

var l = 100000
    , expected = []

while(l--) expected.push(l * Math.random())

var fs = from(expected.slice())

spec(fs).readable().validateOnExit()

read(fs, function (err, arr) {
		a.deepEqual(arr, expected)
    test.done()
  })
}

exports['large stream - callback return true'] = function (test) {

var fs = from(function (i, next) {
    this.emit('data', i)
    if(i >= 99999)
      return this.emit('end')
		return true;
  })

spec(fs).readable().validateOnExit()

read(fs, function (err, arr) {
    test.equal(arr.length, 100000)
    test.done()
  })
}

exports['large stream - callback call next()'] = function (test) {

var fs = from(function (i, next) {
    this.emit('data', i)
    if(i >= 99999)
      return this.emit('end')
		next();
  })

spec(fs).readable().validateOnExit()

read(fs, function (err, arr) {
    test.equal(arr.length, 100000)
    test.done()
  })
}

exports['simple'] = function (test) {

var l = 1000
    , expected = []

while(l--) expected.push(l * Math.random())

var t = from(expected.slice())

spec(t)
    .readable()
    .pausable({strict: true})
    .validateOnExit()

read(t, function (err, actual) {
    if(err) test.error(err) //fail
    a.deepEqual(actual, expected)
    test.done()
  })

}

exports['simple pausable'] = function (test) {

var l = 1000
    , expected = []

while(l--) expected.push(l * Math.random())

var t = from(expected.slice())

spec(t)
    .readable()
    .pausable({strict: true})
    .validateOnExit()

pause(t)

read(t, function (err, actual) {
    if(err) test.error(err) //fail
    a.deepEqual(actual, expected)
    test.done()
  })

}

exports['simple (not strictly pausable) setTimeout'] = function (test) {

var l = 10
    , expected = [] 
  while(l--) expected.push(l * Math.random())

var _expected = expected.slice()
  var t = from(function (i, n) {
    var self = this
    setTimeout(function () {
      if(_expected.length)
        self.emit('data', _expected.shift())
      else
        if(!self.ended)
          self.emit('end')
      n()
    }, 3)
  })

/*
    using from in this way will not be strictly pausable.
    it could be extended to buffer outputs, but I think a better
    way would be to use a PauseStream that implements strict pause.
  */

spec(t)
    .readable()
    .pausable({strict: false })
    .validateOnExit()

//pause(t)
  var paused = false
  var i = setInterval(function () {
    if(!paused) t.pause()
    else t.resume()
    paused = !paused
  }, 2)

t.on('end', function () {
    clearInterval(i)
  })

read(t, function (err, actual) {
    if(err) test.error(err) //fail
    a.deepEqual(actual, expected)
    test.done()
  })

}

Urban Research Lab

Urban Research Lab

The Urban Research Lab (URL) at IIIT-Delhi was established in 2020, during a time when the pandemic brought the complexities of urban life more visible than ever. What started as an initiative by faculty and students has grown into a collaborative space for critically exploring and reimagining the urban questions through research, dialogue, and interdisciplinary engagement.