1'use strict';
2const common = require('../common');
3const assert = require('assert');
4
5const stream = require('stream');
6let state = 0;
7
8
9// What you do:
10//
11// const stream = new stream.Transform({
12//   transform: function transformCallback(chunk, _, next) {
13//     // part 1
14//     this.push(chunk);
15//     //part 2
16//     next();
17//   },
18//   final: function endCallback(done) {
19//     // part 1
20//     process.nextTick(function () {
21//       // part 2
22//       done();
23//     });
24//   },
25//   flush: function flushCallback(done) {
26//     // part 1
27//     process.nextTick(function () {
28//       // part 2
29//       done();
30//     });
31//   }
32// });
33// t.on('data', dataListener);
34// t.on('end', endListener);
35// t.on('finish', finishListener);
36// t.write(1);
37// t.write(4);
38// t.end(7, endMethodCallback);
39//
40// The order things are called
41
42// 1. transformCallback part 1
43// 2. dataListener
44// 3. transformCallback part 2
45// 4. transformCallback part 1
46// 5. dataListener
47// 6. transformCallback part 2
48// 7. transformCallback part 1
49// 8. dataListener
50// 9. transformCallback part 2
51// 10. finalCallback part 1
52// 11. finalCallback part 2
53// 12. flushCallback part 1
54// 13. finishListener
55// 14. endMethodCallback
56// 15. flushCallback part 2
57// 16. endListener
58
59const t = new stream.Transform({
60  objectMode: true,
61  transform: common.mustCall(function(chunk, _, next) {
62    // transformCallback part 1
63    assert.strictEqual(++state, chunk);
64    this.push(state);
65    // transformCallback part 2
66    assert.strictEqual(++state, chunk + 2);
67    process.nextTick(next);
68  }, 3),
69  final: common.mustCall(function(done) {
70    state++;
71    // finalCallback part 1
72    assert.strictEqual(state, 10);
73    setTimeout(function() {
74      state++;
75      // finalCallback part 2
76      assert.strictEqual(state, 11);
77      done();
78    }, 100);
79  }, 1),
80  flush: common.mustCall(function(done) {
81    state++;
82    // flushCallback part 1
83    assert.strictEqual(state, 12);
84    process.nextTick(function() {
85      state++;
86      // flushCallback part 2
87      assert.strictEqual(state, 13);
88      done();
89    });
90  }, 1)
91});
92t.on('finish', common.mustCall(function() {
93  state++;
94  // finishListener
95  assert.strictEqual(state, 15);
96}, 1));
97t.on('end', common.mustCall(function() {
98  state++;
99  // end event
100  assert.strictEqual(state, 16);
101}, 1));
102t.on('data', common.mustCall(function(d) {
103  // dataListener
104  assert.strictEqual(++state, d + 1);
105}, 3));
106t.write(1);
107t.write(4);
108t.end(7, common.mustCall(function() {
109  state++;
110  // endMethodCallback
111  assert.strictEqual(state, 14);
112}, 1));
113